[workflows] Add diff artifact to dart format check for debugging

.github/workflows/format-check-dart.yml

@@ -25,4 +25,23 @@ jobs:
     - name: Check for changes
       run: |
         git ls-files -m
-        if [[ `git ls-files -m` ]]; then echo "Detected Dart formatting errors!" && exit 1; fi
+        if [[ `git ls-files -m` ]]; then 
+          echo "Detected Dart formatting errors!"
+          echo "Creating diff files..."
+          mkdir -p dart-format-diff
+          git diff > dart-format-diff/full-diff.txt
+          git ls-files -m > dart-format-diff/modified-files.txt
+          for file in $(git ls-files -m | head -10); do
+            echo "=== Diff for $file ===" >> dart-format-diff/file-diffs.txt
+            git diff "$file" >> dart-format-diff/file-diffs.txt
+            echo -e "\n\n" >> dart-format-diff/file-diffs.txt
+          done
+          exit 1
+        fi
+    
+    - name: Upload diff artifact
+      if: failure()
+      uses: actions/upload-artifact@v3
+      with:
+        name: dart-format-diff
+        path: dart-format-diff/

spine-c/README.md

@@ -20,6 +20,10 @@ spine-c works with data exported from spine 4.3.xx.
 
 spine-c supports all spine features.
 
+## Usage
+
+### [Please see the spine-c guide for full documentation](http://esotericsoftware.com/spine-c)
+
 ## Setup
 
 ### Manual Copy
@@ -44,10 +48,6 @@ add_subdirectory(${spine-runtimes_SOURCE_DIR}/spine-c ${spine-runtimes_BINARY_DI
 target_link_libraries(your_target PRIVATE spine-c)
 ```
 
-## Usage
-
-### [Please see the spine-c guide for full documentation](http://esotericsoftware.com/spine-c)
-
 ## Runtimes extending spine-c
 - [spine-ios](../spine-ios)
 - [spine-flutter](../spine-flutter)

spine-cpp/README.md

@@ -52,3 +52,5 @@ target_link_libraries(your_target PRIVATE spine-cpp)
 - [spine-sfml](../spine-sfml/cpp)
 - [spine-cocos2dx](../spine-cocos2dx)
 - [spine-ue](../spine-ue)
+- [spine-flutter (via spine-c & FFI)](../spine-flutter)
+- [spine-ios (via spine-c & FFI)](../spine-ios)

spine-ios/Sources/Spine/Generated/AlphaTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineAlphaTimeline)
+@objcMembers
+public final class AlphaTimeline: CurveTimeline1, SlotTimeline {
+    internal let wrappee: spine_alpha_timeline
+
+    internal init(_ wrappee: spine_alpha_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, slotIndex: Int32) {
+        let ptr = spine_alpha_timeline_create(frameCount, bezierCount, slotIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_alpha_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_alpha_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getSlotIndex() -> Int32 {
+        return spine_alpha_timeline_get_slot_index(wrappee)
+    }
+
+    public func setSlotIndex(inValue: Int32) {
+        spine_alpha_timeline_set_slot_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_alpha_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_alpha_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_alpha_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_alpha_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_alpha_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_alpha_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_alpha_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_alpha_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_alpha_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_alpha_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_alpha_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_alpha_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_alpha_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_alpha_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_alpha_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_alpha_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_alpha_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_alpha_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Animation.swift

@@ -0,0 +1,101 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineAnimation)
+@objcMembers
+public final class Animation: NSObject {
+    internal let wrappee: spine_animation
+
+    internal init(_ wrappee: spine_animation) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? Animation else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(name: String?, timelines: ArrayTimeline, duration: Float) {
+        let ptr = spine_animation_create(name, timelines, duration)
+        self.init(ptr)
+    }
+
+    public func getTimelines() -> ArrayTimeline {
+        return spine_animation_get_timelines(wrappee)
+    }
+
+    public func setTimelines(timelines: ArrayTimeline) {
+        spine_animation_set_timelines(wrappee, timelines)
+    }
+
+    public func hasTimeline(ids: ArrayPropertyId) -> Bool {
+        return spine_animation_has_timeline(wrappee, ids) != 0
+    }
+
+    public func getDuration() -> Float {
+        return spine_animation_get_duration(wrappee)
+    }
+
+    public func setDuration(inValue: Float) {
+        spine_animation_set_duration(wrappee, inValue)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, loop: Bool, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_animation_apply(wrappee, skeleton.wrappee, lastTime, time, loop ? 1 : 0, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getName() -> String? {
+        let result = spine_animation_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getBones() -> ArrayInt {
+        return spine_animation_get_bones(wrappee)
+    }
+
+    public func search(values: ArrayFloat, target: Float) -> Int32 {
+        return spine_animation_search_1(wrappee, values, target)
+    }
+
+    public func search(values: ArrayFloat, target: Float, step: Int32) -> Int32 {
+        return spine_animation_search_2(wrappee, values, target, step)
+    }
+
+    deinit {
+        spine_animation_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/AnimationState.swift

@@ -0,0 +1,156 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineAnimationState)
+@objcMembers
+public final class AnimationState: NSObject {
+    internal let wrappee: spine_animation_state
+
+    internal init(_ wrappee: spine_animation_state) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? AnimationState else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(data: AnimationStateData) {
+        let ptr = spine_animation_state_create(data.wrappee)
+        self.init(ptr)
+    }
+
+    public func update(delta: Float) {
+        spine_animation_state_update(wrappee, delta)
+    }
+
+    public func apply(skeleton: Skeleton) -> Bool {
+        return spine_animation_state_apply(wrappee, skeleton.wrappee) != 0
+    }
+
+    public func clearTracks() {
+        spine_animation_state_clear_tracks(wrappee)
+    }
+
+    public func clearTrack(trackIndex: size_t) {
+        spine_animation_state_clear_track(wrappee, trackIndex)
+    }
+
+    public func setAnimation(trackIndex: size_t, animationName: String?, loop: Bool) -> TrackEntry {
+        let result = spine_animation_state_set_animation_1(wrappee, trackIndex, animationName?.cString(using: .utf8), loop ? 1 : 0)
+        return TrackEntry(result)
+    }
+
+    public func setAnimation(trackIndex: size_t, animation: Animation, loop: Bool) -> TrackEntry {
+        let result = spine_animation_state_set_animation_2(wrappee, trackIndex, animation.wrappee, loop ? 1 : 0)
+        return TrackEntry(result)
+    }
+
+    public func addAnimation(trackIndex: size_t, animationName: String?, loop: Bool, delay: Float) -> TrackEntry {
+        let result = spine_animation_state_add_animation_1(wrappee, trackIndex, animationName?.cString(using: .utf8), loop ? 1 : 0, delay)
+        return TrackEntry(result)
+    }
+
+    public func addAnimation(trackIndex: size_t, animation: Animation, loop: Bool, delay: Float) -> TrackEntry {
+        let result = spine_animation_state_add_animation_2(wrappee, trackIndex, animation.wrappee, loop ? 1 : 0, delay)
+        return TrackEntry(result)
+    }
+
+    public func setEmptyAnimation(trackIndex: size_t, mixDuration: Float) -> TrackEntry {
+        let result = spine_animation_state_set_empty_animation(wrappee, trackIndex, mixDuration)
+        return TrackEntry(result)
+    }
+
+    public func addEmptyAnimation(trackIndex: size_t, mixDuration: Float, delay: Float) -> TrackEntry {
+        let result = spine_animation_state_add_empty_animation(wrappee, trackIndex, mixDuration, delay)
+        return TrackEntry(result)
+    }
+
+    public func setEmptyAnimations(mixDuration: Float) {
+        spine_animation_state_set_empty_animations(wrappee, mixDuration)
+    }
+
+    public func getCurrent(trackIndex: size_t) -> TrackEntry {
+        let result = spine_animation_state_get_current(wrappee, trackIndex)
+        return TrackEntry(result)
+    }
+
+    public func getData() -> AnimationStateData {
+        let result = spine_animation_state_get_data(wrappee)
+        return AnimationStateData(result)
+    }
+
+    public func getTracks() -> ArrayTrackEntry {
+        return spine_animation_state_get_tracks(wrappee)
+    }
+
+    public func getTimeScale() -> Float {
+        return spine_animation_state_get_time_scale(wrappee)
+    }
+
+    public func setTimeScale(inValue: Float) {
+        spine_animation_state_set_time_scale(wrappee, inValue)
+    }
+
+    public func disableQueue() {
+        spine_animation_state_disable_queue(wrappee)
+    }
+
+    public func enableQueue() {
+        spine_animation_state_enable_queue(wrappee)
+    }
+
+    public func setManualTrackEntryDisposal(inValue: Bool) {
+        spine_animation_state_set_manual_track_entry_disposal(wrappee, inValue ? 1 : 0)
+    }
+
+    public func getManualTrackEntryDisposal() -> Bool {
+        return spine_animation_state_get_manual_track_entry_disposal(wrappee) != 0
+    }
+
+    public func disposeTrackEntry(entry: TrackEntry) {
+        spine_animation_state_dispose_track_entry(wrappee, entry.wrappee)
+    }
+
+    public func getRendererObject() -> OpaquePointer? {
+        return spine_animation_state_get_renderer_object(wrappee)
+    }
+
+    deinit {
+        spine_animation_state_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/AnimationStateData.swift

@@ -0,0 +1,89 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineAnimationStateData)
+@objcMembers
+public final class AnimationStateData: NSObject {
+    internal let wrappee: spine_animation_state_data
+
+    internal init(_ wrappee: spine_animation_state_data) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? AnimationStateData else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(skeletonData: SkeletonData) {
+        let ptr = spine_animation_state_data_create(skeletonData.wrappee)
+        self.init(ptr)
+    }
+
+    public func getSkeletonData() -> SkeletonData {
+        let result = spine_animation_state_data_get_skeleton_data(wrappee)
+        return SkeletonData(result)
+    }
+
+    public func getDefaultMix() -> Float {
+        return spine_animation_state_data_get_default_mix(wrappee)
+    }
+
+    public func setDefaultMix(inValue: Float) {
+        spine_animation_state_data_set_default_mix(wrappee, inValue)
+    }
+
+    public func setMix(fromName: String?, toName: String?, duration: Float) {
+        spine_animation_state_data_set_mix_1(wrappee, fromName?.cString(using: .utf8), toName?.cString(using: .utf8), duration)
+    }
+
+    public func setMix(from: Animation, to: Animation, duration: Float) {
+        spine_animation_state_data_set_mix_2(wrappee, from.wrappee, to.wrappee, duration)
+    }
+
+    public func getMix(from: Animation, to: Animation) -> Float {
+        return spine_animation_state_data_get_mix(wrappee, from.wrappee, to.wrappee)
+    }
+
+    public func clear() {
+        spine_animation_state_data_clear(wrappee)
+    }
+
+    deinit {
+        spine_animation_state_data_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Arrays.swift

@@ -0,0 +1,29 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation

spine-ios/Sources/Spine/Generated/Atlas.swift

@@ -0,0 +1,72 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineAtlas)
+@objcMembers
+public final class Atlas: NSObject {
+    internal let wrappee: spine_atlas
+
+    internal init(_ wrappee: spine_atlas) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? Atlas else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public func flipV() {
+        spine_atlas_flip_v(wrappee)
+    }
+
+    public func findRegion(name: String?) -> AtlasRegion {
+        let result = spine_atlas_find_region(wrappee, name?.cString(using: .utf8))
+        return AtlasRegion(result)
+    }
+
+    public func getPages() -> ArrayAtlasPage {
+        return spine_atlas_get_pages(wrappee)
+    }
+
+    public func getRegions() -> ArrayAtlasRegion {
+        return spine_atlas_get_regions(wrappee)
+    }
+
+    deinit {
+        spine_atlas_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/AtlasAttachmentLoader.swift

@@ -0,0 +1,95 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineAtlasAttachmentLoader)
+@objcMembers
+public final class AtlasAttachmentLoader: NSObject, AttachmentLoader {
+    internal let wrappee: spine_atlas_attachment_loader
+
+    internal init(_ wrappee: spine_atlas_attachment_loader) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? AtlasAttachmentLoader else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(atlas: Atlas) {
+        let ptr = spine_atlas_attachment_loader_create(atlas.wrappee)
+        self.init(ptr)
+    }
+
+    public func newRegionAttachment(skin: Skin, name: String?, path: String?, sequence: Sequence) -> RegionAttachment {
+        let result = spine_atlas_attachment_loader_new_region_attachment(wrappee, skin.wrappee, name?.cString(using: .utf8), path?.cString(using: .utf8), sequence.wrappee)
+        return RegionAttachment(result)
+    }
+
+    public func newMeshAttachment(skin: Skin, name: String?, path: String?, sequence: Sequence) -> MeshAttachment {
+        let result = spine_atlas_attachment_loader_new_mesh_attachment(wrappee, skin.wrappee, name?.cString(using: .utf8), path?.cString(using: .utf8), sequence.wrappee)
+        return MeshAttachment(result)
+    }
+
+    public func newBoundingBoxAttachment(skin: Skin, name: String?) -> BoundingBoxAttachment {
+        let result = spine_atlas_attachment_loader_new_bounding_box_attachment(wrappee, skin.wrappee, name?.cString(using: .utf8))
+        return BoundingBoxAttachment(result)
+    }
+
+    public func newPathAttachment(skin: Skin, name: String?) -> PathAttachment {
+        let result = spine_atlas_attachment_loader_new_path_attachment(wrappee, skin.wrappee, name?.cString(using: .utf8))
+        return PathAttachment(result)
+    }
+
+    public func newPointAttachment(skin: Skin, name: String?) -> PointAttachment {
+        let result = spine_atlas_attachment_loader_new_point_attachment(wrappee, skin.wrappee, name?.cString(using: .utf8))
+        return PointAttachment(result)
+    }
+
+    public func newClippingAttachment(skin: Skin, name: String?) -> ClippingAttachment {
+        let result = spine_atlas_attachment_loader_new_clipping_attachment(wrappee, skin.wrappee, name?.cString(using: .utf8))
+        return ClippingAttachment(result)
+    }
+
+    public func findRegion(name: String?) -> AtlasRegion {
+        let result = spine_atlas_attachment_loader_find_region(wrappee, name?.cString(using: .utf8))
+        return AtlasRegion(result)
+    }
+
+    deinit {
+        spine_atlas_attachment_loader_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/AtlasPage.swift

@@ -0,0 +1,158 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineAtlasPage)
+@objcMembers
+public final class AtlasPage: NSObject {
+    internal let wrappee: spine_atlas_page
+
+    internal init(_ wrappee: spine_atlas_page) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? AtlasPage else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(inName: String?) {
+        let ptr = spine_atlas_page_create(inName)
+        self.init(ptr)
+    }
+
+    public func getName() -> String? {
+        let result = spine_atlas_page_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func setName(value: String?) {
+        spine_atlas_page_set_name(wrappee, value?.cString(using: .utf8))
+    }
+
+    public func getTexturePath() -> String? {
+        let result = spine_atlas_page_get_texture_path(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func setTexturePath(value: String?) {
+        spine_atlas_page_set_texture_path(wrappee, value?.cString(using: .utf8))
+    }
+
+    public func getFormat() -> Format {
+        return spine_atlas_page_get_format(wrappee)
+    }
+
+    public func setFormat(value: Format) {
+        spine_atlas_page_set_format(wrappee, value)
+    }
+
+    public func getMinFilter() -> TextureFilter {
+        return spine_atlas_page_get_min_filter(wrappee)
+    }
+
+    public func setMinFilter(value: TextureFilter) {
+        spine_atlas_page_set_min_filter(wrappee, value)
+    }
+
+    public func getMagFilter() -> TextureFilter {
+        return spine_atlas_page_get_mag_filter(wrappee)
+    }
+
+    public func setMagFilter(value: TextureFilter) {
+        spine_atlas_page_set_mag_filter(wrappee, value)
+    }
+
+    public func getUWrap() -> TextureWrap {
+        return spine_atlas_page_get_u_wrap(wrappee)
+    }
+
+    public func setUWrap(value: TextureWrap) {
+        spine_atlas_page_set_u_wrap(wrappee, value)
+    }
+
+    public func getVWrap() -> TextureWrap {
+        return spine_atlas_page_get_v_wrap(wrappee)
+    }
+
+    public func setVWrap(value: TextureWrap) {
+        spine_atlas_page_set_v_wrap(wrappee, value)
+    }
+
+    public func getWidth() -> Int32 {
+        return spine_atlas_page_get_width(wrappee)
+    }
+
+    public func setWidth(value: Int32) {
+        spine_atlas_page_set_width(wrappee, value)
+    }
+
+    public func getHeight() -> Int32 {
+        return spine_atlas_page_get_height(wrappee)
+    }
+
+    public func setHeight(value: Int32) {
+        spine_atlas_page_set_height(wrappee, value)
+    }
+
+    public func getPma() -> Bool {
+        return spine_atlas_page_get_pma(wrappee) != 0
+    }
+
+    public func setPma(value: Bool) {
+        spine_atlas_page_set_pma(wrappee, value ? 1 : 0)
+    }
+
+    public func getIndex() -> Int32 {
+        return spine_atlas_page_get_index(wrappee)
+    }
+
+    public func setIndex(value: Int32) {
+        spine_atlas_page_set_index(wrappee, value)
+    }
+
+    public func getTexture() -> OpaquePointer? {
+        return spine_atlas_page_get_texture(wrappee)
+    }
+
+    public func setTexture(value: OpaquePointer?) {
+        spine_atlas_page_set_texture(wrappee, value)
+    }
+
+    deinit {
+        spine_atlas_page_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/AtlasRegion.swift

@@ -0,0 +1,237 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineAtlasRegion)
+@objcMembers
+public final class AtlasRegion: TextureRegion {
+    internal let wrappee: spine_atlas_region
+
+    internal init(_ wrappee: spine_atlas_region) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init() {
+        let ptr = spine_atlas_region_create()
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_atlas_region_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func getPage() -> AtlasPage {
+        let result = spine_atlas_region_get_page(wrappee)
+        return AtlasPage(result)
+    }
+
+    public func getName() -> String? {
+        let result = spine_atlas_region_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getIndex() -> Int32 {
+        return spine_atlas_region_get_index(wrappee)
+    }
+
+    public func getX() -> Int32 {
+        return spine_atlas_region_get_x(wrappee)
+    }
+
+    public func getY() -> Int32 {
+        return spine_atlas_region_get_y(wrappee)
+    }
+
+    public func getOffsetX() -> Float {
+        return spine_atlas_region_get_offset_x(wrappee)
+    }
+
+    public func getOffsetY() -> Float {
+        return spine_atlas_region_get_offset_y(wrappee)
+    }
+
+    public func getPackedWidth() -> Int32 {
+        return spine_atlas_region_get_packed_width(wrappee)
+    }
+
+    public func getPackedHeight() -> Int32 {
+        return spine_atlas_region_get_packed_height(wrappee)
+    }
+
+    public func getOriginalWidth() -> Int32 {
+        return spine_atlas_region_get_original_width(wrappee)
+    }
+
+    public func getOriginalHeight() -> Int32 {
+        return spine_atlas_region_get_original_height(wrappee)
+    }
+
+    public func getRotate() -> Bool {
+        return spine_atlas_region_get_rotate(wrappee) != 0
+    }
+
+    public func getDegrees() -> Int32 {
+        return spine_atlas_region_get_degrees(wrappee)
+    }
+
+    public func getSplits() -> ArrayInt {
+        return spine_atlas_region_get_splits(wrappee)
+    }
+
+    public func getPads() -> ArrayInt {
+        return spine_atlas_region_get_pads(wrappee)
+    }
+
+    public func getValues() -> ArrayFloat {
+        return spine_atlas_region_get_values(wrappee)
+    }
+
+    public func setPage(value: AtlasPage) {
+        spine_atlas_region_set_page(wrappee, value.wrappee)
+    }
+
+    public func setName(value: String?) {
+        spine_atlas_region_set_name(wrappee, value?.cString(using: .utf8))
+    }
+
+    public func setIndex(value: Int32) {
+        spine_atlas_region_set_index(wrappee, value)
+    }
+
+    public func setX(value: Int32) {
+        spine_atlas_region_set_x(wrappee, value)
+    }
+
+    public func setY(value: Int32) {
+        spine_atlas_region_set_y(wrappee, value)
+    }
+
+    public func setOffsetX(value: Float) {
+        spine_atlas_region_set_offset_x(wrappee, value)
+    }
+
+    public func setOffsetY(value: Float) {
+        spine_atlas_region_set_offset_y(wrappee, value)
+    }
+
+    public func setPackedWidth(value: Int32) {
+        spine_atlas_region_set_packed_width(wrappee, value)
+    }
+
+    public func setPackedHeight(value: Int32) {
+        spine_atlas_region_set_packed_height(wrappee, value)
+    }
+
+    public func setOriginalWidth(value: Int32) {
+        spine_atlas_region_set_original_width(wrappee, value)
+    }
+
+    public func setOriginalHeight(value: Int32) {
+        spine_atlas_region_set_original_height(wrappee, value)
+    }
+
+    public func setRotate(value: Bool) {
+        spine_atlas_region_set_rotate(wrappee, value ? 1 : 0)
+    }
+
+    public func setDegrees(value: Int32) {
+        spine_atlas_region_set_degrees(wrappee, value)
+    }
+
+    public func setSplits(value: ArrayInt) {
+        spine_atlas_region_set_splits(wrappee, value)
+    }
+
+    public func setPads(value: ArrayInt) {
+        spine_atlas_region_set_pads(wrappee, value)
+    }
+
+    public func setValues(value: ArrayFloat) {
+        spine_atlas_region_set_values(wrappee, value)
+    }
+
+    public func getU() -> Float {
+        return spine_atlas_region_get_u(wrappee)
+    }
+
+    public func setU(value: Float) {
+        spine_atlas_region_set_u(wrappee, value)
+    }
+
+    public func getV() -> Float {
+        return spine_atlas_region_get_v(wrappee)
+    }
+
+    public func setV(value: Float) {
+        spine_atlas_region_set_v(wrappee, value)
+    }
+
+    public func getU2() -> Float {
+        return spine_atlas_region_get_u2(wrappee)
+    }
+
+    public func setU2(value: Float) {
+        spine_atlas_region_set_u2(wrappee, value)
+    }
+
+    public func getV2() -> Float {
+        return spine_atlas_region_get_v2(wrappee)
+    }
+
+    public func setV2(value: Float) {
+        spine_atlas_region_set_v2(wrappee, value)
+    }
+
+    public func getRegionWidth() -> Int32 {
+        return spine_atlas_region_get_region_width(wrappee)
+    }
+
+    public func setRegionWidth(value: Int32) {
+        spine_atlas_region_set_region_width(wrappee, value)
+    }
+
+    public func getRegionHeight() -> Int32 {
+        return spine_atlas_region_get_region_height(wrappee)
+    }
+
+    public func setRegionHeight(value: Int32) {
+        spine_atlas_region_set_region_height(wrappee, value)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_atlas_region_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_atlas_region_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Attachment.swift

@@ -0,0 +1,87 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineAttachment)
+@objcMembers
+public final class Attachment: NSObject {
+    internal let wrappee: spine_attachment
+
+    internal init(_ wrappee: spine_attachment) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? Attachment else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_attachment_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func getName() -> String? {
+        let result = spine_attachment_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func copy() -> Attachment {
+        let result = spine_attachment_copy(wrappee)
+        return Attachment(result)
+    }
+
+    public func getRefCount() -> Int32 {
+        return spine_attachment_get_ref_count(wrappee)
+    }
+
+    public func reference() {
+        spine_attachment_reference(wrappee)
+    }
+
+    public func dereference() {
+        spine_attachment_dereference(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_attachment_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_attachment_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/AttachmentLoader.swift

@@ -0,0 +1,85 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineAttachmentLoader)
+@objcMembers
+public final class AttachmentLoader {
+    internal let wrappee: spine_attachment_loader
+
+    internal init(_ wrappee: spine_attachment_loader) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? AttachmentLoader else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public func newRegionAttachment(skin: Skin, name: String?, path: String?, sequence: Sequence) -> RegionAttachment {
+        let result = spine_attachment_loader_new_region_attachment(wrappee, skin.wrappee, name?.cString(using: .utf8), path?.cString(using: .utf8), sequence.wrappee)
+        return RegionAttachment(result)
+    }
+
+    public func newMeshAttachment(skin: Skin, name: String?, path: String?, sequence: Sequence) -> MeshAttachment {
+        let result = spine_attachment_loader_new_mesh_attachment(wrappee, skin.wrappee, name?.cString(using: .utf8), path?.cString(using: .utf8), sequence.wrappee)
+        return MeshAttachment(result)
+    }
+
+    public func newBoundingBoxAttachment(skin: Skin, name: String?) -> BoundingBoxAttachment {
+        let result = spine_attachment_loader_new_bounding_box_attachment(wrappee, skin.wrappee, name?.cString(using: .utf8))
+        return BoundingBoxAttachment(result)
+    }
+
+    public func newPathAttachment(skin: Skin, name: String?) -> PathAttachment {
+        let result = spine_attachment_loader_new_path_attachment(wrappee, skin.wrappee, name?.cString(using: .utf8))
+        return PathAttachment(result)
+    }
+
+    public func newPointAttachment(skin: Skin, name: String?) -> PointAttachment {
+        let result = spine_attachment_loader_new_point_attachment(wrappee, skin.wrappee, name?.cString(using: .utf8))
+        return PointAttachment(result)
+    }
+
+    public func newClippingAttachment(skin: Skin, name: String?) -> ClippingAttachment {
+        let result = spine_attachment_loader_new_clipping_attachment(wrappee, skin.wrappee, name?.cString(using: .utf8))
+        return ClippingAttachment(result)
+    }
+
+    deinit {
+        spine_attachment_loader_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/AttachmentTimeline.swift

@@ -0,0 +1,95 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineAttachmentTimeline)
+@objcMembers
+public final class AttachmentTimeline: Timeline, SlotTimeline {
+    internal let wrappee: spine_attachment_timeline
+
+    internal init(_ wrappee: spine_attachment_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, slotIndex: Int32) {
+        let ptr = spine_attachment_timeline_create(frameCount, slotIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_attachment_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_attachment_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func setFrame(frame: Int32, time: Float, attachmentName: String?) {
+        spine_attachment_timeline_set_frame(wrappee, frame, time, attachmentName?.cString(using: .utf8))
+    }
+
+    public func getSlotIndex() -> Int32 {
+        return spine_attachment_timeline_get_slot_index(wrappee)
+    }
+
+    public func setSlotIndex(inValue: Int32) {
+        spine_attachment_timeline_set_slot_index(wrappee, inValue)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_attachment_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_attachment_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_attachment_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_attachment_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_attachment_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_attachment_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_attachment_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Bone.swift

@@ -0,0 +1,120 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineBone)
+@objcMembers
+public final class Bone: PosedActive, Posed, Update {
+    internal let wrappee: spine_bone
+
+    internal init(_ wrappee: spine_bone) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(data: BoneData, parent: Bone) {
+        let ptr = spine_bone_create(data.wrappee, parent.wrappee)
+        self.init(ptr)
+    }
+
+    public convenience init(bone: Bone, parent: Bone) {
+        let ptr = spine_bone_create(bone.wrappee, parent.wrappee)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_bone_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func getParent() -> Bone {
+        let result = spine_bone_get_parent(wrappee)
+        return Bone(result)
+    }
+
+    public func getChildren() -> ArrayBone {
+        return spine_bone_get_children(wrappee)
+    }
+
+    public func isYDown() -> Bool {
+        return spine_bone_is_y_down(wrappee) != 0
+    }
+
+    public func setYDown(value: Bool) {
+        spine_bone_set_y_down(wrappee, value ? 1 : 0)
+    }
+
+    public func update(skeleton: Skeleton, physics: Physics) {
+        spine_bone_update(wrappee, skeleton.wrappee, physics)
+    }
+
+    public func getData() -> BoneData {
+        let result = spine_bone_get_data(wrappee)
+        return BoneData(result)
+    }
+
+    public func getPose() -> BoneLocal {
+        let result = spine_bone_get_pose(wrappee)
+        return BoneLocal(result)
+    }
+
+    public func getAppliedPose() -> BonePose {
+        let result = spine_bone_get_applied_pose(wrappee)
+        return BonePose(result)
+    }
+
+    public func resetConstrained() {
+        spine_bone_reset_constrained(wrappee)
+    }
+
+    public func constrained() {
+        spine_bone_constrained(wrappee)
+    }
+
+    public func isPoseEqualToApplied() -> Bool {
+        return spine_bone_is_pose_equal_to_applied(wrappee) != 0
+    }
+
+    public func isActive() -> Bool {
+        return spine_bone_is_active(wrappee) != 0
+    }
+
+    public func setActive(active: Bool) {
+        spine_bone_set_active(wrappee, active ? 1 : 0)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_bone_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_bone_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/BoneData.swift

@@ -0,0 +1,106 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineBoneData)
+@objcMembers
+public final class BoneData: PosedData {
+    internal let wrappee: spine_bone_data
+
+    internal init(_ wrappee: spine_bone_data) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(index: Int32, name: String?, parent: BoneData) {
+        let ptr = spine_bone_data_create(index, name, parent.wrappee)
+        self.init(ptr)
+    }
+
+    public func getIndex() -> Int32 {
+        return spine_bone_data_get_index(wrappee)
+    }
+
+    public func getParent() -> BoneData {
+        let result = spine_bone_data_get_parent(wrappee)
+        return BoneData(result)
+    }
+
+    public func getLength() -> Float {
+        return spine_bone_data_get_length(wrappee)
+    }
+
+    public func setLength(inValue: Float) {
+        spine_bone_data_set_length(wrappee, inValue)
+    }
+
+    public func getColor() -> Color {
+        let result = spine_bone_data_get_color(wrappee)
+        return Color(result)
+    }
+
+    public func getIcon() -> String? {
+        let result = spine_bone_data_get_icon(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func setIcon(icon: String?) {
+        spine_bone_data_set_icon(wrappee, icon?.cString(using: .utf8))
+    }
+
+    public func getVisible() -> Bool {
+        return spine_bone_data_get_visible(wrappee) != 0
+    }
+
+    public func setVisible(inValue: Bool) {
+        spine_bone_data_set_visible(wrappee, inValue ? 1 : 0)
+    }
+
+    public func getSetupPose() -> BoneLocal {
+        let result = spine_bone_data_get_setup_pose(wrappee)
+        return BoneLocal(result)
+    }
+
+    public func getName() -> String? {
+        let result = spine_bone_data_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getSkinRequired() -> Bool {
+        return spine_bone_data_get_skin_required(wrappee) != 0
+    }
+
+    public func setSkinRequired(skinRequired: Bool) {
+        spine_bone_data_set_skin_required(wrappee, skinRequired ? 1 : 0)
+    }
+
+    deinit {
+        spine_bone_data_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/BoneLocal.swift

@@ -0,0 +1,140 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineBoneLocal)
+@objcMembers
+public final class BoneLocal: NSObject {
+    internal let wrappee: spine_bone_local
+
+    internal init(_ wrappee: spine_bone_local) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? BoneLocal else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init() {
+        let ptr = spine_bone_local_create()
+        self.init(ptr)
+    }
+
+    public func set(pose: BoneLocal) {
+        spine_bone_local_set(wrappee, pose.wrappee)
+    }
+
+    public func getX() -> Float {
+        return spine_bone_local_get_x(wrappee)
+    }
+
+    public func setX(x: Float) {
+        spine_bone_local_set_x(wrappee, x)
+    }
+
+    public func getY() -> Float {
+        return spine_bone_local_get_y(wrappee)
+    }
+
+    public func setY(y: Float) {
+        spine_bone_local_set_y(wrappee, y)
+    }
+
+    public func setPosition(x: Float, y: Float) {
+        spine_bone_local_set_position(wrappee, x, y)
+    }
+
+    public func getRotation() -> Float {
+        return spine_bone_local_get_rotation(wrappee)
+    }
+
+    public func setRotation(rotation: Float) {
+        spine_bone_local_set_rotation(wrappee, rotation)
+    }
+
+    public func getScaleX() -> Float {
+        return spine_bone_local_get_scale_x(wrappee)
+    }
+
+    public func setScaleX(scaleX: Float) {
+        spine_bone_local_set_scale_x(wrappee, scaleX)
+    }
+
+    public func getScaleY() -> Float {
+        return spine_bone_local_get_scale_y(wrappee)
+    }
+
+    public func setScaleY(scaleY: Float) {
+        spine_bone_local_set_scale_y(wrappee, scaleY)
+    }
+
+    public func setScale(scaleX: Float, scaleY: Float) {
+        spine_bone_local_set_scale_1(wrappee, scaleX, scaleY)
+    }
+
+    public func setScale(scale: Float) {
+        spine_bone_local_set_scale_2(wrappee, scale)
+    }
+
+    public func getShearX() -> Float {
+        return spine_bone_local_get_shear_x(wrappee)
+    }
+
+    public func setShearX(shearX: Float) {
+        spine_bone_local_set_shear_x(wrappee, shearX)
+    }
+
+    public func getShearY() -> Float {
+        return spine_bone_local_get_shear_y(wrappee)
+    }
+
+    public func setShearY(shearY: Float) {
+        spine_bone_local_set_shear_y(wrappee, shearY)
+    }
+
+    public func getInherit() -> Inherit {
+        return spine_bone_local_get_inherit(wrappee)
+    }
+
+    public func setInherit(inherit: Inherit) {
+        spine_bone_local_set_inherit(wrappee, inherit)
+    }
+
+    deinit {
+        spine_bone_local_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/BonePose.swift

@@ -0,0 +1,259 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineBonePose)
+@objcMembers
+public final class BonePose: BoneLocal, Update {
+    internal let wrappee: spine_bone_pose
+
+    internal init(_ wrappee: spine_bone_pose) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init() {
+        let ptr = spine_bone_pose_create()
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_bone_pose_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func update(skeleton: Skeleton, physics: Physics) {
+        spine_bone_pose_update(wrappee, skeleton.wrappee, physics)
+    }
+
+    public func updateWorldTransform(skeleton: Skeleton) {
+        spine_bone_pose_update_world_transform(wrappee, skeleton.wrappee)
+    }
+
+    public func updateLocalTransform(skeleton: Skeleton) {
+        spine_bone_pose_update_local_transform(wrappee, skeleton.wrappee)
+    }
+
+    public func validateLocalTransform(skeleton: Skeleton) {
+        spine_bone_pose_validate_local_transform(wrappee, skeleton.wrappee)
+    }
+
+    public func modifyLocal(skeleton: Skeleton) {
+        spine_bone_pose_modify_local(wrappee, skeleton.wrappee)
+    }
+
+    public func modifyWorld(update: Int32) {
+        spine_bone_pose_modify_world(wrappee, update)
+    }
+
+    public func resetWorld(update: Int32) {
+        spine_bone_pose_reset_world(wrappee, update)
+    }
+
+    public func getA() -> Float {
+        return spine_bone_pose_get_a(wrappee)
+    }
+
+    public func setA(a: Float) {
+        spine_bone_pose_set_a(wrappee, a)
+    }
+
+    public func getB() -> Float {
+        return spine_bone_pose_get_b(wrappee)
+    }
+
+    public func setB(b: Float) {
+        spine_bone_pose_set_b(wrappee, b)
+    }
+
+    public func getC() -> Float {
+        return spine_bone_pose_get_c(wrappee)
+    }
+
+    public func setC(c: Float) {
+        spine_bone_pose_set_c(wrappee, c)
+    }
+
+    public func getD() -> Float {
+        return spine_bone_pose_get_d(wrappee)
+    }
+
+    public func setD(d: Float) {
+        spine_bone_pose_set_d(wrappee, d)
+    }
+
+    public func getWorldX() -> Float {
+        return spine_bone_pose_get_world_x(wrappee)
+    }
+
+    public func setWorldX(worldX: Float) {
+        spine_bone_pose_set_world_x(wrappee, worldX)
+    }
+
+    public func getWorldY() -> Float {
+        return spine_bone_pose_get_world_y(wrappee)
+    }
+
+    public func setWorldY(worldY: Float) {
+        spine_bone_pose_set_world_y(wrappee, worldY)
+    }
+
+    public func getWorldRotationX() -> Float {
+        return spine_bone_pose_get_world_rotation_x(wrappee)
+    }
+
+    public func getWorldRotationY() -> Float {
+        return spine_bone_pose_get_world_rotation_y(wrappee)
+    }
+
+    public func getWorldScaleX() -> Float {
+        return spine_bone_pose_get_world_scale_x(wrappee)
+    }
+
+    public func getWorldScaleY() -> Float {
+        return spine_bone_pose_get_world_scale_y(wrappee)
+    }
+
+    public func worldToLocal(worldX: Float, worldY: Float, outLocalX: UnsafeMutablePointer<Float>?, outLocalY: UnsafeMutablePointer<Float>?) {
+        spine_bone_pose_world_to_local(wrappee, worldX, worldY, outLocalX, outLocalY)
+    }
+
+    public func localToWorld(localX: Float, localY: Float, outWorldX: UnsafeMutablePointer<Float>?, outWorldY: UnsafeMutablePointer<Float>?) {
+        spine_bone_pose_local_to_world(wrappee, localX, localY, outWorldX, outWorldY)
+    }
+
+    public func worldToParent(worldX: Float, worldY: Float, outParentX: UnsafeMutablePointer<Float>?, outParentY: UnsafeMutablePointer<Float>?) {
+        spine_bone_pose_world_to_parent(wrappee, worldX, worldY, outParentX, outParentY)
+    }
+
+    public func parentToWorld(parentX: Float, parentY: Float, outWorldX: UnsafeMutablePointer<Float>?, outWorldY: UnsafeMutablePointer<Float>?) {
+        spine_bone_pose_parent_to_world(wrappee, parentX, parentY, outWorldX, outWorldY)
+    }
+
+    public func worldToLocalRotation(worldRotation: Float) -> Float {
+        return spine_bone_pose_world_to_local_rotation(wrappee, worldRotation)
+    }
+
+    public func localToWorldRotation(localRotation: Float) -> Float {
+        return spine_bone_pose_local_to_world_rotation(wrappee, localRotation)
+    }
+
+    public func rotateWorld(degrees: Float) {
+        spine_bone_pose_rotate_world(wrappee, degrees)
+    }
+
+    public func set(pose: BoneLocal) {
+        spine_bone_pose_set(wrappee, pose.wrappee)
+    }
+
+    public func getX() -> Float {
+        return spine_bone_pose_get_x(wrappee)
+    }
+
+    public func setX(x: Float) {
+        spine_bone_pose_set_x(wrappee, x)
+    }
+
+    public func getY() -> Float {
+        return spine_bone_pose_get_y(wrappee)
+    }
+
+    public func setY(y: Float) {
+        spine_bone_pose_set_y(wrappee, y)
+    }
+
+    public func setPosition(x: Float, y: Float) {
+        spine_bone_pose_set_position(wrappee, x, y)
+    }
+
+    public func getRotation() -> Float {
+        return spine_bone_pose_get_rotation(wrappee)
+    }
+
+    public func setRotation(rotation: Float) {
+        spine_bone_pose_set_rotation(wrappee, rotation)
+    }
+
+    public func getScaleX() -> Float {
+        return spine_bone_pose_get_scale_x(wrappee)
+    }
+
+    public func setScaleX(scaleX: Float) {
+        spine_bone_pose_set_scale_x(wrappee, scaleX)
+    }
+
+    public func getScaleY() -> Float {
+        return spine_bone_pose_get_scale_y(wrappee)
+    }
+
+    public func setScaleY(scaleY: Float) {
+        spine_bone_pose_set_scale_y(wrappee, scaleY)
+    }
+
+    public func setScale(scaleX: Float, scaleY: Float) {
+        spine_bone_pose_set_scale_1(wrappee, scaleX, scaleY)
+    }
+
+    public func setScale(scale: Float) {
+        spine_bone_pose_set_scale_2(wrappee, scale)
+    }
+
+    public func getShearX() -> Float {
+        return spine_bone_pose_get_shear_x(wrappee)
+    }
+
+    public func setShearX(shearX: Float) {
+        spine_bone_pose_set_shear_x(wrappee, shearX)
+    }
+
+    public func getShearY() -> Float {
+        return spine_bone_pose_get_shear_y(wrappee)
+    }
+
+    public func setShearY(shearY: Float) {
+        spine_bone_pose_set_shear_y(wrappee, shearY)
+    }
+
+    public func getInherit() -> Inherit {
+        return spine_bone_pose_get_inherit(wrappee)
+    }
+
+    public func setInherit(inherit: Inherit) {
+        spine_bone_pose_set_inherit(wrappee, inherit)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_bone_pose_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_bone_pose_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/BoneTimeline.swift

@@ -0,0 +1,73 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineBoneTimeline)
+@objcMembers
+public final class BoneTimeline {
+    internal let wrappee: spine_bone_timeline
+
+    internal init(_ wrappee: spine_bone_timeline) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? BoneTimeline else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_bone_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func getBoneIndex() -> Int32 {
+        return spine_bone_timeline_get_bone_index(wrappee)
+    }
+
+    public func setBoneIndex(inValue: Int32) {
+        spine_bone_timeline_set_bone_index(wrappee, inValue)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_bone_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_bone_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/BoneTimeline1.swift

@@ -0,0 +1,130 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineBoneTimeline1)
+@objcMembers
+public final class BoneTimeline1: CurveTimeline1, BoneTimeline {
+    internal let wrappee: spine_bone_timeline1
+
+    internal init(_ wrappee: spine_bone_timeline1) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_bone_timeline1_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_bone_timeline1_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getBoneIndex() -> Int32 {
+        return spine_bone_timeline1_get_bone_index(wrappee)
+    }
+
+    public func setBoneIndex(inValue: Int32) {
+        spine_bone_timeline1_set_bone_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_bone_timeline1_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_bone_timeline1_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_bone_timeline1_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_bone_timeline1_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_bone_timeline1_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_bone_timeline1_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_bone_timeline1_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_bone_timeline1_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_bone_timeline1_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_bone_timeline1_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_bone_timeline1_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_bone_timeline1_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_bone_timeline1_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_bone_timeline1_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_bone_timeline1_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_bone_timeline1_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_bone_timeline1_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_bone_timeline1_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/BoneTimeline2.swift

@@ -0,0 +1,110 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineBoneTimeline2)
+@objcMembers
+public final class BoneTimeline2: CurveTimeline, BoneTimeline {
+    internal let wrappee: spine_bone_timeline2
+
+    internal init(_ wrappee: spine_bone_timeline2) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_bone_timeline2_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_bone_timeline2_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getBoneIndex() -> Int32 {
+        return spine_bone_timeline2_get_bone_index(wrappee)
+    }
+
+    public func setBoneIndex(inValue: Int32) {
+        spine_bone_timeline2_set_bone_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value1: Float, value2: Float) {
+        spine_bone_timeline2_set_frame(wrappee, frame, time, value1, value2)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_bone_timeline2_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_bone_timeline2_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_bone_timeline2_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_bone_timeline2_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_bone_timeline2_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_bone_timeline2_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_bone_timeline2_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_bone_timeline2_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_bone_timeline2_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_bone_timeline2_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_bone_timeline2_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_bone_timeline2_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/BoundingBoxAttachment.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineBoundingBoxAttachment)
+@objcMembers
+public final class BoundingBoxAttachment: VertexAttachment {
+    internal let wrappee: spine_bounding_box_attachment
+
+    internal init(_ wrappee: spine_bounding_box_attachment) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(name: String?) {
+        let ptr = spine_bounding_box_attachment_create(name)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_bounding_box_attachment_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func getColor() -> Color {
+        let result = spine_bounding_box_attachment_get_color(wrappee)
+        return Color(result)
+    }
+
+    public func copy() -> Attachment {
+        let result = spine_bounding_box_attachment_copy(wrappee)
+        return Attachment(result)
+    }
+
+    public func computeWorldVertices(skeleton: Skeleton, slot: Slot, start: size_t, count: size_t, worldVertices: UnsafeMutablePointer<Float>?, offset: size_t, stride: size_t) {
+        spine_bounding_box_attachment_compute_world_vertices_1(wrappee, skeleton.wrappee, slot.wrappee, start, count, worldVertices, offset, stride)
+    }
+
+    public func computeWorldVertices(skeleton: Skeleton, slot: Slot, start: size_t, count: size_t, worldVertices: ArrayFloat, offset: size_t, stride: size_t) {
+        spine_bounding_box_attachment_compute_world_vertices_2(wrappee, skeleton.wrappee, slot.wrappee, start, count, worldVertices, offset, stride)
+    }
+
+    public func getId() -> Int32 {
+        return spine_bounding_box_attachment_get_id(wrappee)
+    }
+
+    public func getBones() -> ArrayInt {
+        return spine_bounding_box_attachment_get_bones(wrappee)
+    }
+
+    public func setBones(bones: ArrayInt) {
+        spine_bounding_box_attachment_set_bones(wrappee, bones)
+    }
+
+    public func getVertices() -> ArrayFloat {
+        return spine_bounding_box_attachment_get_vertices(wrappee)
+    }
+
+    public func setVertices(vertices: ArrayFloat) {
+        spine_bounding_box_attachment_set_vertices(wrappee, vertices)
+    }
+
+    public func getWorldVerticesLength() -> size_t {
+        return spine_bounding_box_attachment_get_world_vertices_length(wrappee)
+    }
+
+    public func setWorldVerticesLength(inValue: size_t) {
+        spine_bounding_box_attachment_set_world_vertices_length(wrappee, inValue)
+    }
+
+    public func getTimelineAttachment() -> Attachment {
+        let result = spine_bounding_box_attachment_get_timeline_attachment(wrappee)
+        return Attachment(result)
+    }
+
+    public func setTimelineAttachment(attachment: Attachment) {
+        spine_bounding_box_attachment_set_timeline_attachment(wrappee, attachment.wrappee)
+    }
+
+    public func copyTo(other: VertexAttachment) {
+        spine_bounding_box_attachment_copy_to(wrappee, other.wrappee)
+    }
+
+    public func getName() -> String? {
+        let result = spine_bounding_box_attachment_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getRefCount() -> Int32 {
+        return spine_bounding_box_attachment_get_ref_count(wrappee)
+    }
+
+    public func reference() {
+        spine_bounding_box_attachment_reference(wrappee)
+    }
+
+    public func dereference() {
+        spine_bounding_box_attachment_dereference(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_bounding_box_attachment_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_bounding_box_attachment_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/ClippingAttachment.swift

@@ -0,0 +1,144 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineClippingAttachment)
+@objcMembers
+public final class ClippingAttachment: VertexAttachment {
+    internal let wrappee: spine_clipping_attachment
+
+    internal init(_ wrappee: spine_clipping_attachment) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(name: String?) {
+        let ptr = spine_clipping_attachment_create(name)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_clipping_attachment_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func getEndSlot() -> SlotData {
+        let result = spine_clipping_attachment_get_end_slot(wrappee)
+        return SlotData(result)
+    }
+
+    public func setEndSlot(inValue: SlotData) {
+        spine_clipping_attachment_set_end_slot(wrappee, inValue.wrappee)
+    }
+
+    public func getColor() -> Color {
+        let result = spine_clipping_attachment_get_color(wrappee)
+        return Color(result)
+    }
+
+    public func copy() -> Attachment {
+        let result = spine_clipping_attachment_copy(wrappee)
+        return Attachment(result)
+    }
+
+    public func computeWorldVertices(skeleton: Skeleton, slot: Slot, start: size_t, count: size_t, worldVertices: UnsafeMutablePointer<Float>?, offset: size_t, stride: size_t) {
+        spine_clipping_attachment_compute_world_vertices_1(wrappee, skeleton.wrappee, slot.wrappee, start, count, worldVertices, offset, stride)
+    }
+
+    public func computeWorldVertices(skeleton: Skeleton, slot: Slot, start: size_t, count: size_t, worldVertices: ArrayFloat, offset: size_t, stride: size_t) {
+        spine_clipping_attachment_compute_world_vertices_2(wrappee, skeleton.wrappee, slot.wrappee, start, count, worldVertices, offset, stride)
+    }
+
+    public func getId() -> Int32 {
+        return spine_clipping_attachment_get_id(wrappee)
+    }
+
+    public func getBones() -> ArrayInt {
+        return spine_clipping_attachment_get_bones(wrappee)
+    }
+
+    public func setBones(bones: ArrayInt) {
+        spine_clipping_attachment_set_bones(wrappee, bones)
+    }
+
+    public func getVertices() -> ArrayFloat {
+        return spine_clipping_attachment_get_vertices(wrappee)
+    }
+
+    public func setVertices(vertices: ArrayFloat) {
+        spine_clipping_attachment_set_vertices(wrappee, vertices)
+    }
+
+    public func getWorldVerticesLength() -> size_t {
+        return spine_clipping_attachment_get_world_vertices_length(wrappee)
+    }
+
+    public func setWorldVerticesLength(inValue: size_t) {
+        spine_clipping_attachment_set_world_vertices_length(wrappee, inValue)
+    }
+
+    public func getTimelineAttachment() -> Attachment {
+        let result = spine_clipping_attachment_get_timeline_attachment(wrappee)
+        return Attachment(result)
+    }
+
+    public func setTimelineAttachment(attachment: Attachment) {
+        spine_clipping_attachment_set_timeline_attachment(wrappee, attachment.wrappee)
+    }
+
+    public func copyTo(other: VertexAttachment) {
+        spine_clipping_attachment_copy_to(wrappee, other.wrappee)
+    }
+
+    public func getName() -> String? {
+        let result = spine_clipping_attachment_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getRefCount() -> Int32 {
+        return spine_clipping_attachment_get_ref_count(wrappee)
+    }
+
+    public func reference() {
+        spine_clipping_attachment_reference(wrappee)
+    }
+
+    public func dereference() {
+        spine_clipping_attachment_dereference(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_clipping_attachment_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_clipping_attachment_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Color.swift

@@ -0,0 +1,144 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineColor)
+@objcMembers
+public final class Color: NSObject {
+    internal let wrappee: spine_color
+
+    internal init(_ wrappee: spine_color) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? Color else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init() {
+        let ptr = spine_color_create()
+        self.init(ptr)
+    }
+
+    public convenience init(r: Float, g: Float, b: Float, a: Float) {
+        let ptr = spine_color_create(r, g, b, a)
+        self.init(ptr)
+    }
+
+    public func set(_r: Float, _g: Float, _b: Float, _a: Float) -> Color {
+        let result = spine_color_set_1(wrappee, _r, _g, _b, _a)
+        return Color(result)
+    }
+
+    public func set(_r: Float, _g: Float, _b: Float) -> Color {
+        let result = spine_color_set_2(wrappee, _r, _g, _b)
+        return Color(result)
+    }
+
+    public func set(other: Color) -> Color {
+        let result = spine_color_set_3(wrappee, other.wrappee)
+        return Color(result)
+    }
+
+    public func add(_r: Float, _g: Float, _b: Float, _a: Float) -> Color {
+        let result = spine_color_add_1(wrappee, _r, _g, _b, _a)
+        return Color(result)
+    }
+
+    public func add(_r: Float, _g: Float, _b: Float) -> Color {
+        let result = spine_color_add_2(wrappee, _r, _g, _b)
+        return Color(result)
+    }
+
+    public func add(other: Color) -> Color {
+        let result = spine_color_add_3(wrappee, other.wrappee)
+        return Color(result)
+    }
+
+    public func clamp() -> Color {
+        let result = spine_color_clamp(wrappee)
+        return Color(result)
+    }
+
+    public func parseHex(value: String?, index: size_t) -> Float {
+        return spine_color_parse_hex(wrappee, value?.cString(using: .utf8), index)
+    }
+
+    public func rgba8888ToColor(color: Color, value: Int32) {
+        spine_color_rgba8888_to_color(wrappee, color.wrappee, value)
+    }
+
+    public func rgb888ToColor(color: Color, value: Int32) {
+        spine_color_rgb888_to_color(wrappee, color.wrappee, value)
+    }
+
+    public func getR() -> Float {
+        return spine_color_get_r(wrappee)
+    }
+
+    public func setR(value: Float) {
+        spine_color_set_r(wrappee, value)
+    }
+
+    public func getG() -> Float {
+        return spine_color_get_g(wrappee)
+    }
+
+    public func setG(value: Float) {
+        spine_color_set_g(wrappee, value)
+    }
+
+    public func getB() -> Float {
+        return spine_color_get_b(wrappee)
+    }
+
+    public func setB(value: Float) {
+        spine_color_set_b(wrappee, value)
+    }
+
+    public func getA() -> Float {
+        return spine_color_get_a(wrappee)
+    }
+
+    public func setA(value: Float) {
+        spine_color_set_a(wrappee, value)
+    }
+
+    deinit {
+        spine_color_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Constraint.swift

@@ -0,0 +1,82 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineConstraint)
+@objcMembers
+public final class Constraint: Update {
+    internal let wrappee: spine_constraint
+
+    internal init(_ wrappee: spine_constraint) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? Constraint else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_constraint_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func getData() -> ConstraintData {
+        let result = spine_constraint_get_data(wrappee)
+        return ConstraintData(result)
+    }
+
+    public func sort(skeleton: Skeleton) {
+        spine_constraint_sort(wrappee, skeleton.wrappee)
+    }
+
+    public func isSourceActive() -> Bool {
+        return spine_constraint_is_source_active(wrappee) != 0
+    }
+
+    public func update(skeleton: Skeleton, physics: Physics) {
+        spine_constraint_update(wrappee, skeleton.wrappee, physics)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_constraint_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_constraint_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/ConstraintData.swift

@@ -0,0 +1,79 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineConstraintData)
+@objcMembers
+public final class ConstraintData {
+    internal let wrappee: spine_constraint_data
+
+    internal init(_ wrappee: spine_constraint_data) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? ConstraintData else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_constraint_data_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func createMethod(skeleton: Skeleton) -> Constraint {
+        let result = spine_constraint_data_create_method(wrappee, skeleton.wrappee)
+        return Constraint(result)
+    }
+
+    public func getName() -> String? {
+        let result = spine_constraint_data_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getSkinRequired() -> Bool {
+        return spine_constraint_data_get_skin_required(wrappee) != 0
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_constraint_data_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_constraint_data_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/ConstraintTimeline.swift

@@ -0,0 +1,73 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineConstraintTimeline)
+@objcMembers
+public final class ConstraintTimeline {
+    internal let wrappee: spine_constraint_timeline
+
+    internal init(_ wrappee: spine_constraint_timeline) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? ConstraintTimeline else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_constraint_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_constraint_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_constraint_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_constraint_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_constraint_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/ConstraintTimeline1.swift

@@ -0,0 +1,130 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineConstraintTimeline1)
+@objcMembers
+public final class ConstraintTimeline1: CurveTimeline1, ConstraintTimeline {
+    internal let wrappee: spine_constraint_timeline1
+
+    internal init(_ wrappee: spine_constraint_timeline1) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_constraint_timeline1_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_constraint_timeline1_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_constraint_timeline1_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_constraint_timeline1_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_constraint_timeline1_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_constraint_timeline1_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_constraint_timeline1_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_constraint_timeline1_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_constraint_timeline1_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_constraint_timeline1_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_constraint_timeline1_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_constraint_timeline1_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_constraint_timeline1_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_constraint_timeline1_get_curves(wrappee)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_constraint_timeline1_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_constraint_timeline1_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_constraint_timeline1_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_constraint_timeline1_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_constraint_timeline1_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_constraint_timeline1_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_constraint_timeline1_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_constraint_timeline1_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/CurveTimeline.swift

@@ -0,0 +1,98 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineCurveTimeline)
+@objcMembers
+public final class CurveTimeline: Timeline {
+    internal let wrappee: spine_curve_timeline
+
+    internal init(_ wrappee: spine_curve_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_curve_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_curve_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_curve_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_curve_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_curve_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_curve_timeline_get_curves(wrappee)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_curve_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_curve_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_curve_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_curve_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_curve_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_curve_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_curve_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_curve_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/CurveTimeline1.swift

@@ -0,0 +1,122 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineCurveTimeline1)
+@objcMembers
+public final class CurveTimeline1: CurveTimeline {
+    internal let wrappee: spine_curve_timeline1
+
+    internal init(_ wrappee: spine_curve_timeline1) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_curve_timeline1_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_curve_timeline1_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_curve_timeline1_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_curve_timeline1_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_curve_timeline1_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_curve_timeline1_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_curve_timeline1_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_curve_timeline1_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_curve_timeline1_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_curve_timeline1_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_curve_timeline1_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_curve_timeline1_get_curves(wrappee)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_curve_timeline1_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_curve_timeline1_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_curve_timeline1_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_curve_timeline1_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_curve_timeline1_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_curve_timeline1_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_curve_timeline1_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_curve_timeline1_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/DeformTimeline.swift

@@ -0,0 +1,128 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineDeformTimeline)
+@objcMembers
+public final class DeformTimeline: SlotCurveTimeline {
+    internal let wrappee: spine_deform_timeline
+
+    internal init(_ wrappee: spine_deform_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, slotIndex: Int32, attachment: VertexAttachment) {
+        let ptr = spine_deform_timeline_create(frameCount, bezierCount, slotIndex, attachment.wrappee)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_deform_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func setFrame(frameIndex: Int32, time: Float, vertices: ArrayFloat) {
+        spine_deform_timeline_set_frame(wrappee, frameIndex, time, vertices)
+    }
+
+    public func getAttachment() -> VertexAttachment {
+        let result = spine_deform_timeline_get_attachment(wrappee)
+        return VertexAttachment(result)
+    }
+
+    public func setAttachment(inValue: VertexAttachment) {
+        spine_deform_timeline_set_attachment(wrappee, inValue.wrappee)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_deform_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getCurvePercent(time: Float, frame: Int32) -> Float {
+        return spine_deform_timeline_get_curve_percent(wrappee, time, frame)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_deform_timeline_get_frame_count(wrappee)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_deform_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getSlotIndex() -> Int32 {
+        return spine_deform_timeline_get_slot_index(wrappee)
+    }
+
+    public func setSlotIndex(inValue: Int32) {
+        spine_deform_timeline_set_slot_index(wrappee, inValue)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_deform_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_deform_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_deform_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_deform_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_deform_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_deform_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_deform_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_deform_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_deform_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_deform_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/DrawOrderTimeline.swift

@@ -0,0 +1,87 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineDrawOrderTimeline)
+@objcMembers
+public final class DrawOrderTimeline: Timeline {
+    internal let wrappee: spine_draw_order_timeline
+
+    internal init(_ wrappee: spine_draw_order_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t) {
+        let ptr = spine_draw_order_timeline_create(frameCount)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_draw_order_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_draw_order_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_draw_order_timeline_get_frame_count(wrappee)
+    }
+
+    public func setFrame(frame: size_t, time: Float, drawOrder: ArrayInt) {
+        spine_draw_order_timeline_set_frame(wrappee, frame, time, drawOrder)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_draw_order_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_draw_order_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_draw_order_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_draw_order_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_draw_order_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_draw_order_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Enums.swift

@@ -0,0 +1,45 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+public typealias AttachmentType = spine_attachment_type
+public typealias BlendMode = spine_blend_mode
+public typealias EventType = spine_event_type
+public typealias Format = spine_format
+public typealias Inherit = spine_inherit
+public typealias MixBlend = spine_mix_blend
+public typealias MixDirection = spine_mix_direction
+public typealias Physics = spine_physics
+public typealias PositionMode = spine_position_mode
+public typealias Property = spine_property
+public typealias RotateMode = spine_rotate_mode
+public typealias SequenceMode = spine_sequence_mode
+public typealias SpacingMode = spine_spacing_mode
+public typealias TextureFilter = spine_texture_filter
+public typealias TextureWrap = spine_texture_wrap

spine-ios/Sources/Spine/Generated/Event.swift

@@ -0,0 +1,110 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineEvent)
+@objcMembers
+public final class Event: NSObject {
+    internal let wrappee: spine_event
+
+    internal init(_ wrappee: spine_event) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? Event else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(time: Float, data: EventData) {
+        let ptr = spine_event_create(time, data.wrappee)
+        self.init(ptr)
+    }
+
+    public func getData() -> EventData {
+        let result = spine_event_get_data(wrappee)
+        return EventData(result)
+    }
+
+    public func getTime() -> Float {
+        return spine_event_get_time(wrappee)
+    }
+
+    public func getInt() -> Int32 {
+        return spine_event_get_int(wrappee)
+    }
+
+    public func setInt(inValue: Int32) {
+        spine_event_set_int(wrappee, inValue)
+    }
+
+    public func getFloat() -> Float {
+        return spine_event_get_float(wrappee)
+    }
+
+    public func setFloat(inValue: Float) {
+        spine_event_set_float(wrappee, inValue)
+    }
+
+    public func getString() -> String? {
+        let result = spine_event_get_string(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func setString(inValue: String?) {
+        spine_event_set_string(wrappee, inValue?.cString(using: .utf8))
+    }
+
+    public func getVolume() -> Float {
+        return spine_event_get_volume(wrappee)
+    }
+
+    public func setVolume(inValue: Float) {
+        spine_event_set_volume(wrappee, inValue)
+    }
+
+    public func getBalance() -> Float {
+        return spine_event_get_balance(wrappee)
+    }
+
+    public func setBalance(inValue: Float) {
+        spine_event_set_balance(wrappee, inValue)
+    }
+
+    deinit {
+        spine_event_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/EventData.swift

@@ -0,0 +1,115 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineEventData)
+@objcMembers
+public final class EventData: NSObject {
+    internal let wrappee: spine_event_data
+
+    internal init(_ wrappee: spine_event_data) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? EventData else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(name: String?) {
+        let ptr = spine_event_data_create(name)
+        self.init(ptr)
+    }
+
+    public func getName() -> String? {
+        let result = spine_event_data_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getInt() -> Int32 {
+        return spine_event_data_get_int(wrappee)
+    }
+
+    public func setInt(inValue: Int32) {
+        spine_event_data_set_int(wrappee, inValue)
+    }
+
+    public func getFloat() -> Float {
+        return spine_event_data_get_float(wrappee)
+    }
+
+    public func setFloat(inValue: Float) {
+        spine_event_data_set_float(wrappee, inValue)
+    }
+
+    public func getString() -> String? {
+        let result = spine_event_data_get_string(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func setString(inValue: String?) {
+        spine_event_data_set_string(wrappee, inValue?.cString(using: .utf8))
+    }
+
+    public func getAudioPath() -> String? {
+        let result = spine_event_data_get_audio_path(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func setAudioPath(inValue: String?) {
+        spine_event_data_set_audio_path(wrappee, inValue?.cString(using: .utf8))
+    }
+
+    public func getVolume() -> Float {
+        return spine_event_data_get_volume(wrappee)
+    }
+
+    public func setVolume(inValue: Float) {
+        spine_event_data_set_volume(wrappee, inValue)
+    }
+
+    public func getBalance() -> Float {
+        return spine_event_data_get_balance(wrappee)
+    }
+
+    public func setBalance(inValue: Float) {
+        spine_event_data_set_balance(wrappee, inValue)
+    }
+
+    deinit {
+        spine_event_data_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/EventQueueEntry.swift

@@ -0,0 +1,86 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineEventQueueEntry)
+@objcMembers
+public final class EventQueueEntry: NSObject {
+    internal let wrappee: spine_event_queue_entry
+
+    internal init(_ wrappee: spine_event_queue_entry) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? EventQueueEntry else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(eventType: EventType, trackEntry: TrackEntry, event: Event) {
+        let ptr = spine_event_queue_entry_create(eventType, trackEntry.wrappee, event.wrappee)
+        self.init(ptr)
+    }
+
+    public func getType() -> EventType {
+        return spine_event_queue_entry_get__type(wrappee)
+    }
+
+    public func setType(value: EventType) {
+        spine_event_queue_entry_set__type(wrappee, value)
+    }
+
+    public func getEntry() -> TrackEntry {
+        let result = spine_event_queue_entry_get__entry(wrappee)
+        return TrackEntry(result)
+    }
+
+    public func setEntry(value: TrackEntry) {
+        spine_event_queue_entry_set__entry(wrappee, value.wrappee)
+    }
+
+    public func getEvent() -> Event {
+        let result = spine_event_queue_entry_get__event(wrappee)
+        return Event(result)
+    }
+
+    public func setEvent(value: Event) {
+        spine_event_queue_entry_set__event(wrappee, value.wrappee)
+    }
+
+    deinit {
+        spine_event_queue_entry_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/EventTimeline.swift

@@ -0,0 +1,91 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineEventTimeline)
+@objcMembers
+public final class EventTimeline: Timeline {
+    internal let wrappee: spine_event_timeline
+
+    internal init(_ wrappee: spine_event_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t) {
+        let ptr = spine_event_timeline_create(frameCount)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_event_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_event_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_event_timeline_get_frame_count(wrappee)
+    }
+
+    public func getEvents() -> ArrayEvent {
+        return spine_event_timeline_get_events(wrappee)
+    }
+
+    public func setFrame(frame: size_t, event: Event) {
+        spine_event_timeline_set_frame(wrappee, frame, event.wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_event_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_event_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_event_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_event_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_event_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_event_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/FromProperty.swift

@@ -0,0 +1,85 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineFromProperty)
+@objcMembers
+public final class FromProperty: NSObject {
+    internal let wrappee: spine_from_property
+
+    internal init(_ wrappee: spine_from_property) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? FromProperty else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_from_property_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func value(skeleton: Skeleton, source: BonePose, local: Bool, offsets: UnsafeMutablePointer<Float>?) -> Float {
+        return spine_from_property_value(wrappee, skeleton.wrappee, source.wrappee, local ? 1 : 0, offsets)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_from_property_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func getOffset() -> Float {
+        return spine_from_property_get__offset(wrappee)
+    }
+
+    public func setOffset(value: Float) {
+        spine_from_property_set__offset(wrappee, value)
+    }
+
+    public func getTo() -> ArrayToProperty {
+        return spine_from_property_get__to(wrappee)
+    }
+
+    public func setTo(value: ArrayToProperty) {
+        spine_from_property_set__to(wrappee, value)
+    }
+
+    deinit {
+        spine_from_property_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/FromRotate.swift

@@ -0,0 +1,63 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineFromRotate)
+@objcMembers
+public final class FromRotate: FromProperty {
+    internal let wrappee: spine_from_rotate
+
+    internal init(_ wrappee: spine_from_rotate) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init() {
+        let ptr = spine_from_rotate_create()
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_from_rotate_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func value(skeleton: Skeleton, source: BonePose, local: Bool, offsets: UnsafeMutablePointer<Float>?) -> Float {
+        return spine_from_rotate_value(wrappee, skeleton.wrappee, source.wrappee, local ? 1 : 0, offsets)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_from_rotate_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_from_rotate_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/FromScaleX.swift

@@ -0,0 +1,63 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineFromScaleX)
+@objcMembers
+public final class FromScaleX: FromProperty {
+    internal let wrappee: spine_from_scale_x
+
+    internal init(_ wrappee: spine_from_scale_x) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init() {
+        let ptr = spine_from_scale_x_create()
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_from_scale_x_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func value(skeleton: Skeleton, source: BonePose, local: Bool, offsets: UnsafeMutablePointer<Float>?) -> Float {
+        return spine_from_scale_x_value(wrappee, skeleton.wrappee, source.wrappee, local ? 1 : 0, offsets)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_from_scale_x_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_from_scale_x_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/FromScaleY.swift

@@ -0,0 +1,63 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineFromScaleY)
+@objcMembers
+public final class FromScaleY: FromProperty {
+    internal let wrappee: spine_from_scale_y
+
+    internal init(_ wrappee: spine_from_scale_y) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init() {
+        let ptr = spine_from_scale_y_create()
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_from_scale_y_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func value(skeleton: Skeleton, source: BonePose, local: Bool, offsets: UnsafeMutablePointer<Float>?) -> Float {
+        return spine_from_scale_y_value(wrappee, skeleton.wrappee, source.wrappee, local ? 1 : 0, offsets)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_from_scale_y_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_from_scale_y_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/FromShearY.swift

@@ -0,0 +1,63 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineFromShearY)
+@objcMembers
+public final class FromShearY: FromProperty {
+    internal let wrappee: spine_from_shear_y
+
+    internal init(_ wrappee: spine_from_shear_y) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init() {
+        let ptr = spine_from_shear_y_create()
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_from_shear_y_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func value(skeleton: Skeleton, source: BonePose, local: Bool, offsets: UnsafeMutablePointer<Float>?) -> Float {
+        return spine_from_shear_y_value(wrappee, skeleton.wrappee, source.wrappee, local ? 1 : 0, offsets)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_from_shear_y_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_from_shear_y_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/FromX.swift

@@ -0,0 +1,63 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineFromX)
+@objcMembers
+public final class FromX: FromProperty {
+    internal let wrappee: spine_from_x
+
+    internal init(_ wrappee: spine_from_x) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init() {
+        let ptr = spine_from_x_create()
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_from_x_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func value(skeleton: Skeleton, source: BonePose, local: Bool, offsets: UnsafeMutablePointer<Float>?) -> Float {
+        return spine_from_x_value(wrappee, skeleton.wrappee, source.wrappee, local ? 1 : 0, offsets)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_from_x_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_from_x_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/FromY.swift

@@ -0,0 +1,63 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineFromY)
+@objcMembers
+public final class FromY: FromProperty {
+    internal let wrappee: spine_from_y
+
+    internal init(_ wrappee: spine_from_y) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init() {
+        let ptr = spine_from_y_create()
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_from_y_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func value(skeleton: Skeleton, source: BonePose, local: Bool, offsets: UnsafeMutablePointer<Float>?) -> Float {
+        return spine_from_y_value(wrappee, skeleton.wrappee, source.wrappee, local ? 1 : 0, offsets)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_from_y_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_from_y_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/IkConstraint.swift

@@ -0,0 +1,132 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineIkConstraint)
+@objcMembers
+public final class IkConstraint: PosedActive, Posed, Constraint {
+    internal let wrappee: spine_ik_constraint
+
+    internal init(_ wrappee: spine_ik_constraint) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(data: IkConstraintData, skeleton: Skeleton) {
+        let ptr = spine_ik_constraint_create(data.wrappee, skeleton.wrappee)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_ik_constraint_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func copy(skeleton: Skeleton) -> IkConstraint {
+        let result = spine_ik_constraint_copy(wrappee, skeleton.wrappee)
+        return IkConstraint(result)
+    }
+
+    public func update(skeleton: Skeleton, physics: Physics) {
+        spine_ik_constraint_update(wrappee, skeleton.wrappee, physics)
+    }
+
+    public func sort(skeleton: Skeleton) {
+        spine_ik_constraint_sort(wrappee, skeleton.wrappee)
+    }
+
+    public func isSourceActive() -> Bool {
+        return spine_ik_constraint_is_source_active(wrappee) != 0
+    }
+
+    public func getData() -> IkConstraintData {
+        let result = spine_ik_constraint_get_data(wrappee)
+        return IkConstraintData(result)
+    }
+
+    public func getBones() -> ArrayBonePose {
+        return spine_ik_constraint_get_bones(wrappee)
+    }
+
+    public func getTarget() -> Bone {
+        let result = spine_ik_constraint_get_target(wrappee)
+        return Bone(result)
+    }
+
+    public func setTarget(inValue: Bone) {
+        spine_ik_constraint_set_target(wrappee, inValue.wrappee)
+    }
+
+    public func apply(skeleton: Skeleton, bone: BonePose, targetX: Float, targetY: Float, compress: Bool, stretch: Bool, uniform: Bool, mix: Float) {
+        spine_ik_constraint_apply_1(wrappee, skeleton.wrappee, bone.wrappee, targetX, targetY, compress ? 1 : 0, stretch ? 1 : 0, uniform ? 1 : 0, mix)
+    }
+
+    public func apply(skeleton: Skeleton, parent: BonePose, child: BonePose, targetX: Float, targetY: Float, bendDirection: Int32, stretch: Bool, uniform: Bool, softness: Float, mix: Float) {
+        spine_ik_constraint_apply_2(wrappee, skeleton.wrappee, parent.wrappee, child.wrappee, targetX, targetY, bendDirection, stretch ? 1 : 0, uniform ? 1 : 0, softness, mix)
+    }
+
+    public func getPose() -> IkConstraintPose {
+        let result = spine_ik_constraint_get_pose(wrappee)
+        return IkConstraintPose(result)
+    }
+
+    public func getAppliedPose() -> IkConstraintPose {
+        let result = spine_ik_constraint_get_applied_pose(wrappee)
+        return IkConstraintPose(result)
+    }
+
+    public func resetConstrained() {
+        spine_ik_constraint_reset_constrained(wrappee)
+    }
+
+    public func constrained() {
+        spine_ik_constraint_constrained(wrappee)
+    }
+
+    public func isPoseEqualToApplied() -> Bool {
+        return spine_ik_constraint_is_pose_equal_to_applied(wrappee) != 0
+    }
+
+    public func isActive() -> Bool {
+        return spine_ik_constraint_is_active(wrappee) != 0
+    }
+
+    public func setActive(active: Bool) {
+        spine_ik_constraint_set_active(wrappee, active ? 1 : 0)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_ik_constraint_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_ik_constraint_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/IkConstraintData.swift

@@ -0,0 +1,103 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineIkConstraintData)
+@objcMembers
+public final class IkConstraintData: PosedData, ConstraintData {
+    internal let wrappee: spine_ik_constraint_data
+
+    internal init(_ wrappee: spine_ik_constraint_data) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(name: String?) {
+        let ptr = spine_ik_constraint_data_create(name)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_ik_constraint_data_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func createMethod(skeleton: Skeleton) -> Constraint {
+        let result = spine_ik_constraint_data_create_method(wrappee, skeleton.wrappee)
+        return Constraint(result)
+    }
+
+    public func getBones() -> ArrayBoneData {
+        return spine_ik_constraint_data_get_bones(wrappee)
+    }
+
+    public func getTarget() -> BoneData {
+        let result = spine_ik_constraint_data_get_target(wrappee)
+        return BoneData(result)
+    }
+
+    public func setTarget(inValue: BoneData) {
+        spine_ik_constraint_data_set_target(wrappee, inValue.wrappee)
+    }
+
+    public func getUniform() -> Bool {
+        return spine_ik_constraint_data_get_uniform(wrappee) != 0
+    }
+
+    public func setUniform(uniform: Bool) {
+        spine_ik_constraint_data_set_uniform(wrappee, uniform ? 1 : 0)
+    }
+
+    public func getName() -> String? {
+        let result = spine_ik_constraint_data_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getSkinRequired() -> Bool {
+        return spine_ik_constraint_data_get_skin_required(wrappee) != 0
+    }
+
+    public func getSetupPose() -> IkConstraintPose {
+        let result = spine_ik_constraint_data_get_setup_pose(wrappee)
+        return IkConstraintPose(result)
+    }
+
+    public func setSkinRequired(skinRequired: Bool) {
+        spine_ik_constraint_data_set_skin_required(wrappee, skinRequired ? 1 : 0)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_ik_constraint_data_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_ik_constraint_data_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/IkConstraintPose.swift

@@ -0,0 +1,104 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineIkConstraintPose)
+@objcMembers
+public final class IkConstraintPose: NSObject {
+    internal let wrappee: spine_ik_constraint_pose
+
+    internal init(_ wrappee: spine_ik_constraint_pose) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? IkConstraintPose else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init() {
+        let ptr = spine_ik_constraint_pose_create()
+        self.init(ptr)
+    }
+
+    public func set(pose: IkConstraintPose) {
+        spine_ik_constraint_pose_set(wrappee, pose.wrappee)
+    }
+
+    public func getMix() -> Float {
+        return spine_ik_constraint_pose_get_mix(wrappee)
+    }
+
+    public func setMix(mix: Float) {
+        spine_ik_constraint_pose_set_mix(wrappee, mix)
+    }
+
+    public func getSoftness() -> Float {
+        return spine_ik_constraint_pose_get_softness(wrappee)
+    }
+
+    public func setSoftness(softness: Float) {
+        spine_ik_constraint_pose_set_softness(wrappee, softness)
+    }
+
+    public func getBendDirection() -> Int32 {
+        return spine_ik_constraint_pose_get_bend_direction(wrappee)
+    }
+
+    public func setBendDirection(bendDirection: Int32) {
+        spine_ik_constraint_pose_set_bend_direction(wrappee, bendDirection)
+    }
+
+    public func getCompress() -> Bool {
+        return spine_ik_constraint_pose_get_compress(wrappee) != 0
+    }
+
+    public func setCompress(compress: Bool) {
+        spine_ik_constraint_pose_set_compress(wrappee, compress ? 1 : 0)
+    }
+
+    public func getStretch() -> Bool {
+        return spine_ik_constraint_pose_get_stretch(wrappee) != 0
+    }
+
+    public func setStretch(stretch: Bool) {
+        spine_ik_constraint_pose_set_stretch(wrappee, stretch ? 1 : 0)
+    }
+
+    deinit {
+        spine_ik_constraint_pose_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/IkConstraintTimeline.swift

@@ -0,0 +1,115 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineIkConstraintTimeline)
+@objcMembers
+public final class IkConstraintTimeline: CurveTimeline, ConstraintTimeline {
+    internal let wrappee: spine_ik_constraint_timeline
+
+    internal init(_ wrappee: spine_ik_constraint_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, constraintIndex: Int32) {
+        let ptr = spine_ik_constraint_timeline_create(frameCount, bezierCount, constraintIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_ik_constraint_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_ik_constraint_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func setFrame(frame: Int32, time: Float, mix: Float, softness: Float, bendDirection: Int32, compress: Bool, stretch: Bool) {
+        spine_ik_constraint_timeline_set_frame(wrappee, frame, time, mix, softness, bendDirection, compress ? 1 : 0, stretch ? 1 : 0)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_ik_constraint_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_ik_constraint_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_ik_constraint_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_ik_constraint_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_ik_constraint_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_ik_constraint_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_ik_constraint_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_ik_constraint_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_ik_constraint_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_ik_constraint_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_ik_constraint_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_ik_constraint_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_ik_constraint_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_ik_constraint_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/InheritTimeline.swift

@@ -0,0 +1,95 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineInheritTimeline)
+@objcMembers
+public final class InheritTimeline: Timeline, BoneTimeline {
+    internal let wrappee: spine_inherit_timeline
+
+    internal init(_ wrappee: spine_inherit_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, boneIndex: Int32) {
+        let ptr = spine_inherit_timeline_create(frameCount, boneIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_inherit_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func setFrame(frame: Int32, time: Float, inherit: Inherit) {
+        spine_inherit_timeline_set_frame(wrappee, frame, time, inherit)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_inherit_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getBoneIndex() -> Int32 {
+        return spine_inherit_timeline_get_bone_index(wrappee)
+    }
+
+    public func setBoneIndex(inValue: Int32) {
+        spine_inherit_timeline_set_bone_index(wrappee, inValue)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_inherit_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_inherit_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_inherit_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_inherit_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_inherit_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_inherit_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_inherit_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/LinkedMesh.swift

@@ -0,0 +1,65 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineLinkedMesh)
+@objcMembers
+public final class LinkedMesh {
+    internal let wrappee: spine_linked_mesh
+
+    internal init(_ wrappee: spine_linked_mesh) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? LinkedMesh else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(mesh: MeshAttachment, skinIndex: const int, slotIndex: size_t, parent: String?, inheritTimelines: Bool) {
+        let ptr = spine_linked_mesh_create(mesh.wrappee, skinIndex, slotIndex, parent, inheritTimelines)
+        self.init(ptr)
+    }
+
+    public convenience init(mesh: MeshAttachment, skin: String?, slotIndex: size_t, parent: String?, inheritTimelines: Bool) {
+        let ptr = spine_linked_mesh_create(mesh.wrappee, skin, slotIndex, parent, inheritTimelines)
+        self.init(ptr)
+    }
+
+    deinit {
+        spine_linked_mesh_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/MeshAttachment.swift

@@ -0,0 +1,232 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineMeshAttachment)
+@objcMembers
+public final class MeshAttachment: VertexAttachment {
+    internal let wrappee: spine_mesh_attachment
+
+    internal init(_ wrappee: spine_mesh_attachment) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(name: String?) {
+        let ptr = spine_mesh_attachment_create(name)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_mesh_attachment_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func computeWorldVertices(skeleton: Skeleton, slot: Slot, start: size_t, count: size_t, worldVertices: UnsafeMutablePointer<Float>?, offset: size_t, stride: size_t) {
+        spine_mesh_attachment_compute_world_vertices_1(wrappee, skeleton.wrappee, slot.wrappee, start, count, worldVertices, offset, stride)
+    }
+
+    public func computeWorldVertices(skeleton: Skeleton, slot: Slot, start: size_t, count: size_t, worldVertices: ArrayFloat, offset: size_t, stride: size_t) {
+        spine_mesh_attachment_compute_world_vertices_2(wrappee, skeleton.wrappee, slot.wrappee, start, count, worldVertices, offset, stride)
+    }
+
+    public func updateRegion() {
+        spine_mesh_attachment_update_region(wrappee)
+    }
+
+    public func getHullLength() -> Int32 {
+        return spine_mesh_attachment_get_hull_length(wrappee)
+    }
+
+    public func setHullLength(inValue: Int32) {
+        spine_mesh_attachment_set_hull_length(wrappee, inValue)
+    }
+
+    public func getRegionUVs() -> ArrayFloat {
+        return spine_mesh_attachment_get_region_u_vs(wrappee)
+    }
+
+    public func setRegionUVs(inValue: ArrayFloat) {
+        spine_mesh_attachment_set_region_u_vs(wrappee, inValue)
+    }
+
+    public func getUVs() -> ArrayFloat {
+        return spine_mesh_attachment_get_u_vs(wrappee)
+    }
+
+    public func getTriangles() -> ArrayUnsignedShort {
+        return spine_mesh_attachment_get_triangles(wrappee)
+    }
+
+    public func setTriangles(inValue: ArrayUnsignedShort) {
+        spine_mesh_attachment_set_triangles(wrappee, inValue)
+    }
+
+    public func getColor() -> Color {
+        let result = spine_mesh_attachment_get_color(wrappee)
+        return Color(result)
+    }
+
+    public func getPath() -> String? {
+        let result = spine_mesh_attachment_get_path(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func setPath(inValue: String?) {
+        spine_mesh_attachment_set_path(wrappee, inValue?.cString(using: .utf8))
+    }
+
+    public func getRegion() -> TextureRegion {
+        let result = spine_mesh_attachment_get_region(wrappee)
+        return TextureRegion(result)
+    }
+
+    public func setRegion(region: TextureRegion) {
+        spine_mesh_attachment_set_region(wrappee, region.wrappee)
+    }
+
+    public func getSequence() -> Sequence {
+        let result = spine_mesh_attachment_get_sequence(wrappee)
+        return Sequence(result)
+    }
+
+    public func setSequence(sequence: Sequence) {
+        spine_mesh_attachment_set_sequence(wrappee, sequence.wrappee)
+    }
+
+    public func getParentMesh() -> MeshAttachment {
+        let result = spine_mesh_attachment_get_parent_mesh(wrappee)
+        return MeshAttachment(result)
+    }
+
+    public func setParentMesh(inValue: MeshAttachment) {
+        spine_mesh_attachment_set_parent_mesh(wrappee, inValue.wrappee)
+    }
+
+    public func getEdges() -> ArrayUnsignedShort {
+        return spine_mesh_attachment_get_edges(wrappee)
+    }
+
+    public func setEdges(inValue: ArrayUnsignedShort) {
+        spine_mesh_attachment_set_edges(wrappee, inValue)
+    }
+
+    public func getWidth() -> Float {
+        return spine_mesh_attachment_get_width(wrappee)
+    }
+
+    public func setWidth(inValue: Float) {
+        spine_mesh_attachment_set_width(wrappee, inValue)
+    }
+
+    public func getHeight() -> Float {
+        return spine_mesh_attachment_get_height(wrappee)
+    }
+
+    public func setHeight(inValue: Float) {
+        spine_mesh_attachment_set_height(wrappee, inValue)
+    }
+
+    public func copy() -> Attachment {
+        let result = spine_mesh_attachment_copy(wrappee)
+        return Attachment(result)
+    }
+
+    public func newLinkedMesh() -> MeshAttachment {
+        let result = spine_mesh_attachment_new_linked_mesh(wrappee)
+        return MeshAttachment(result)
+    }
+
+    public func getId() -> Int32 {
+        return spine_mesh_attachment_get_id(wrappee)
+    }
+
+    public func getBones() -> ArrayInt {
+        return spine_mesh_attachment_get_bones(wrappee)
+    }
+
+    public func setBones(bones: ArrayInt) {
+        spine_mesh_attachment_set_bones(wrappee, bones)
+    }
+
+    public func getVertices() -> ArrayFloat {
+        return spine_mesh_attachment_get_vertices(wrappee)
+    }
+
+    public func setVertices(vertices: ArrayFloat) {
+        spine_mesh_attachment_set_vertices(wrappee, vertices)
+    }
+
+    public func getWorldVerticesLength() -> size_t {
+        return spine_mesh_attachment_get_world_vertices_length(wrappee)
+    }
+
+    public func setWorldVerticesLength(inValue: size_t) {
+        spine_mesh_attachment_set_world_vertices_length(wrappee, inValue)
+    }
+
+    public func getTimelineAttachment() -> Attachment {
+        let result = spine_mesh_attachment_get_timeline_attachment(wrappee)
+        return Attachment(result)
+    }
+
+    public func setTimelineAttachment(attachment: Attachment) {
+        spine_mesh_attachment_set_timeline_attachment(wrappee, attachment.wrappee)
+    }
+
+    public func copyTo(other: VertexAttachment) {
+        spine_mesh_attachment_copy_to(wrappee, other.wrappee)
+    }
+
+    public func getName() -> String? {
+        let result = spine_mesh_attachment_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getRefCount() -> Int32 {
+        return spine_mesh_attachment_get_ref_count(wrappee)
+    }
+
+    public func reference() {
+        spine_mesh_attachment_reference(wrappee)
+    }
+
+    public func dereference() {
+        spine_mesh_attachment_dereference(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_mesh_attachment_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_mesh_attachment_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PathAttachment.swift

@@ -0,0 +1,159 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePathAttachment)
+@objcMembers
+public final class PathAttachment: VertexAttachment {
+    internal let wrappee: spine_path_attachment
+
+    internal init(_ wrappee: spine_path_attachment) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(name: String?) {
+        let ptr = spine_path_attachment_create(name)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_path_attachment_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func getLengths() -> ArrayFloat {
+        return spine_path_attachment_get_lengths(wrappee)
+    }
+
+    public func setLengths(inValue: ArrayFloat) {
+        spine_path_attachment_set_lengths(wrappee, inValue)
+    }
+
+    public func getClosed() -> Bool {
+        return spine_path_attachment_get_closed(wrappee) != 0
+    }
+
+    public func setClosed(inValue: Bool) {
+        spine_path_attachment_set_closed(wrappee, inValue ? 1 : 0)
+    }
+
+    public func getConstantSpeed() -> Bool {
+        return spine_path_attachment_get_constant_speed(wrappee) != 0
+    }
+
+    public func setConstantSpeed(inValue: Bool) {
+        spine_path_attachment_set_constant_speed(wrappee, inValue ? 1 : 0)
+    }
+
+    public func getColor() -> Color {
+        let result = spine_path_attachment_get_color(wrappee)
+        return Color(result)
+    }
+
+    public func copy() -> Attachment {
+        let result = spine_path_attachment_copy(wrappee)
+        return Attachment(result)
+    }
+
+    public func computeWorldVertices(skeleton: Skeleton, slot: Slot, start: size_t, count: size_t, worldVertices: UnsafeMutablePointer<Float>?, offset: size_t, stride: size_t) {
+        spine_path_attachment_compute_world_vertices_1(wrappee, skeleton.wrappee, slot.wrappee, start, count, worldVertices, offset, stride)
+    }
+
+    public func computeWorldVertices(skeleton: Skeleton, slot: Slot, start: size_t, count: size_t, worldVertices: ArrayFloat, offset: size_t, stride: size_t) {
+        spine_path_attachment_compute_world_vertices_2(wrappee, skeleton.wrappee, slot.wrappee, start, count, worldVertices, offset, stride)
+    }
+
+    public func getId() -> Int32 {
+        return spine_path_attachment_get_id(wrappee)
+    }
+
+    public func getBones() -> ArrayInt {
+        return spine_path_attachment_get_bones(wrappee)
+    }
+
+    public func setBones(bones: ArrayInt) {
+        spine_path_attachment_set_bones(wrappee, bones)
+    }
+
+    public func getVertices() -> ArrayFloat {
+        return spine_path_attachment_get_vertices(wrappee)
+    }
+
+    public func setVertices(vertices: ArrayFloat) {
+        spine_path_attachment_set_vertices(wrappee, vertices)
+    }
+
+    public func getWorldVerticesLength() -> size_t {
+        return spine_path_attachment_get_world_vertices_length(wrappee)
+    }
+
+    public func setWorldVerticesLength(inValue: size_t) {
+        spine_path_attachment_set_world_vertices_length(wrappee, inValue)
+    }
+
+    public func getTimelineAttachment() -> Attachment {
+        let result = spine_path_attachment_get_timeline_attachment(wrappee)
+        return Attachment(result)
+    }
+
+    public func setTimelineAttachment(attachment: Attachment) {
+        spine_path_attachment_set_timeline_attachment(wrappee, attachment.wrappee)
+    }
+
+    public func copyTo(other: VertexAttachment) {
+        spine_path_attachment_copy_to(wrappee, other.wrappee)
+    }
+
+    public func getName() -> String? {
+        let result = spine_path_attachment_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getRefCount() -> Int32 {
+        return spine_path_attachment_get_ref_count(wrappee)
+    }
+
+    public func reference() {
+        spine_path_attachment_reference(wrappee)
+    }
+
+    public func dereference() {
+        spine_path_attachment_dereference(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_path_attachment_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_path_attachment_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PathConstraint.swift

@@ -0,0 +1,124 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePathConstraint)
+@objcMembers
+public final class PathConstraint: PosedActive, Posed, Constraint {
+    internal let wrappee: spine_path_constraint
+
+    internal init(_ wrappee: spine_path_constraint) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(data: PathConstraintData, skeleton: Skeleton) {
+        let ptr = spine_path_constraint_create(data.wrappee, skeleton.wrappee)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_path_constraint_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func copy(skeleton: Skeleton) -> PathConstraint {
+        let result = spine_path_constraint_copy(wrappee, skeleton.wrappee)
+        return PathConstraint(result)
+    }
+
+    public func update(skeleton: Skeleton, physics: Physics) {
+        spine_path_constraint_update(wrappee, skeleton.wrappee, physics)
+    }
+
+    public func sort(skeleton: Skeleton) {
+        spine_path_constraint_sort(wrappee, skeleton.wrappee)
+    }
+
+    public func isSourceActive() -> Bool {
+        return spine_path_constraint_is_source_active(wrappee) != 0
+    }
+
+    public func getBones() -> ArrayBonePose {
+        return spine_path_constraint_get_bones(wrappee)
+    }
+
+    public func getSlot() -> Slot {
+        let result = spine_path_constraint_get_slot(wrappee)
+        return Slot(result)
+    }
+
+    public func setSlot(slot: Slot) {
+        spine_path_constraint_set_slot(wrappee, slot.wrappee)
+    }
+
+    public func getData() -> PathConstraintData {
+        let result = spine_path_constraint_get_data(wrappee)
+        return PathConstraintData(result)
+    }
+
+    public func getPose() -> PathConstraintPose {
+        let result = spine_path_constraint_get_pose(wrappee)
+        return PathConstraintPose(result)
+    }
+
+    public func getAppliedPose() -> PathConstraintPose {
+        let result = spine_path_constraint_get_applied_pose(wrappee)
+        return PathConstraintPose(result)
+    }
+
+    public func resetConstrained() {
+        spine_path_constraint_reset_constrained(wrappee)
+    }
+
+    public func constrained() {
+        spine_path_constraint_constrained(wrappee)
+    }
+
+    public func isPoseEqualToApplied() -> Bool {
+        return spine_path_constraint_is_pose_equal_to_applied(wrappee) != 0
+    }
+
+    public func isActive() -> Bool {
+        return spine_path_constraint_is_active(wrappee) != 0
+    }
+
+    public func setActive(active: Bool) {
+        spine_path_constraint_set_active(wrappee, active ? 1 : 0)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_path_constraint_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_path_constraint_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PathConstraintData.swift

@@ -0,0 +1,127 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePathConstraintData)
+@objcMembers
+public final class PathConstraintData: PosedData, ConstraintData {
+    internal let wrappee: spine_path_constraint_data
+
+    internal init(_ wrappee: spine_path_constraint_data) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(name: String?) {
+        let ptr = spine_path_constraint_data_create(name)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_path_constraint_data_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func createMethod(skeleton: Skeleton) -> Constraint {
+        let result = spine_path_constraint_data_create_method(wrappee, skeleton.wrappee)
+        return Constraint(result)
+    }
+
+    public func getBones() -> ArrayBoneData {
+        return spine_path_constraint_data_get_bones(wrappee)
+    }
+
+    public func getSlot() -> SlotData {
+        let result = spine_path_constraint_data_get_slot(wrappee)
+        return SlotData(result)
+    }
+
+    public func setSlot(slot: SlotData) {
+        spine_path_constraint_data_set_slot(wrappee, slot.wrappee)
+    }
+
+    public func getPositionMode() -> PositionMode {
+        return spine_path_constraint_data_get_position_mode(wrappee)
+    }
+
+    public func setPositionMode(positionMode: PositionMode) {
+        spine_path_constraint_data_set_position_mode(wrappee, positionMode)
+    }
+
+    public func getSpacingMode() -> SpacingMode {
+        return spine_path_constraint_data_get_spacing_mode(wrappee)
+    }
+
+    public func setSpacingMode(spacingMode: SpacingMode) {
+        spine_path_constraint_data_set_spacing_mode(wrappee, spacingMode)
+    }
+
+    public func getRotateMode() -> RotateMode {
+        return spine_path_constraint_data_get_rotate_mode(wrappee)
+    }
+
+    public func setRotateMode(rotateMode: RotateMode) {
+        spine_path_constraint_data_set_rotate_mode(wrappee, rotateMode)
+    }
+
+    public func getOffsetRotation() -> Float {
+        return spine_path_constraint_data_get_offset_rotation(wrappee)
+    }
+
+    public func setOffsetRotation(offsetRotation: Float) {
+        spine_path_constraint_data_set_offset_rotation(wrappee, offsetRotation)
+    }
+
+    public func getName() -> String? {
+        let result = spine_path_constraint_data_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getSkinRequired() -> Bool {
+        return spine_path_constraint_data_get_skin_required(wrappee) != 0
+    }
+
+    public func getSetupPose() -> PathConstraintPose {
+        let result = spine_path_constraint_data_get_setup_pose(wrappee)
+        return PathConstraintPose(result)
+    }
+
+    public func setSkinRequired(skinRequired: Bool) {
+        spine_path_constraint_data_set_skin_required(wrappee, skinRequired ? 1 : 0)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_path_constraint_data_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_path_constraint_data_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PathConstraintMixTimeline.swift

@@ -0,0 +1,115 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePathConstraintMixTimeline)
+@objcMembers
+public final class PathConstraintMixTimeline: CurveTimeline, ConstraintTimeline {
+    internal let wrappee: spine_path_constraint_mix_timeline
+
+    internal init(_ wrappee: spine_path_constraint_mix_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, constraintIndex: Int32) {
+        let ptr = spine_path_constraint_mix_timeline_create(frameCount, bezierCount, constraintIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_path_constraint_mix_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_path_constraint_mix_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func setFrame(frame: Int32, time: Float, mixRotate: Float, mixX: Float, mixY: Float) {
+        spine_path_constraint_mix_timeline_set_frame(wrappee, frame, time, mixRotate, mixX, mixY)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_path_constraint_mix_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_path_constraint_mix_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_path_constraint_mix_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_path_constraint_mix_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_path_constraint_mix_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_path_constraint_mix_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_path_constraint_mix_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_path_constraint_mix_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_path_constraint_mix_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_path_constraint_mix_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_path_constraint_mix_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_path_constraint_mix_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_path_constraint_mix_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_path_constraint_mix_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PathConstraintPose.swift

@@ -0,0 +1,104 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePathConstraintPose)
+@objcMembers
+public final class PathConstraintPose: NSObject {
+    internal let wrappee: spine_path_constraint_pose
+
+    internal init(_ wrappee: spine_path_constraint_pose) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? PathConstraintPose else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init() {
+        let ptr = spine_path_constraint_pose_create()
+        self.init(ptr)
+    }
+
+    public func set(pose: PathConstraintPose) {
+        spine_path_constraint_pose_set(wrappee, pose.wrappee)
+    }
+
+    public func getPosition() -> Float {
+        return spine_path_constraint_pose_get_position(wrappee)
+    }
+
+    public func setPosition(position: Float) {
+        spine_path_constraint_pose_set_position(wrappee, position)
+    }
+
+    public func getSpacing() -> Float {
+        return spine_path_constraint_pose_get_spacing(wrappee)
+    }
+
+    public func setSpacing(spacing: Float) {
+        spine_path_constraint_pose_set_spacing(wrappee, spacing)
+    }
+
+    public func getMixRotate() -> Float {
+        return spine_path_constraint_pose_get_mix_rotate(wrappee)
+    }
+
+    public func setMixRotate(mixRotate: Float) {
+        spine_path_constraint_pose_set_mix_rotate(wrappee, mixRotate)
+    }
+
+    public func getMixX() -> Float {
+        return spine_path_constraint_pose_get_mix_x(wrappee)
+    }
+
+    public func setMixX(mixX: Float) {
+        spine_path_constraint_pose_set_mix_x(wrappee, mixX)
+    }
+
+    public func getMixY() -> Float {
+        return spine_path_constraint_pose_get_mix_y(wrappee)
+    }
+
+    public func setMixY(mixY: Float) {
+        spine_path_constraint_pose_set_mix_y(wrappee, mixY)
+    }
+
+    deinit {
+        spine_path_constraint_pose_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PathConstraintPositionTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePathConstraintPositionTimeline)
+@objcMembers
+public final class PathConstraintPositionTimeline: ConstraintTimeline1 {
+    internal let wrappee: spine_path_constraint_position_timeline
+
+    internal init(_ wrappee: spine_path_constraint_position_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, constraintIndex: Int32) {
+        let ptr = spine_path_constraint_position_timeline_create(frameCount, bezierCount, constraintIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_path_constraint_position_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_path_constraint_position_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_path_constraint_position_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_path_constraint_position_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_path_constraint_position_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_path_constraint_position_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_path_constraint_position_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_path_constraint_position_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_path_constraint_position_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_path_constraint_position_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_path_constraint_position_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_path_constraint_position_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_path_constraint_position_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_path_constraint_position_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_path_constraint_position_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_path_constraint_position_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_path_constraint_position_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_path_constraint_position_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_path_constraint_position_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_path_constraint_position_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_path_constraint_position_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_path_constraint_position_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PathConstraintSpacingTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePathConstraintSpacingTimeline)
+@objcMembers
+public final class PathConstraintSpacingTimeline: ConstraintTimeline1 {
+    internal let wrappee: spine_path_constraint_spacing_timeline
+
+    internal init(_ wrappee: spine_path_constraint_spacing_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, constraintIndex: Int32) {
+        let ptr = spine_path_constraint_spacing_timeline_create(frameCount, bezierCount, constraintIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_path_constraint_spacing_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_path_constraint_spacing_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_path_constraint_spacing_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_path_constraint_spacing_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_path_constraint_spacing_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_path_constraint_spacing_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_path_constraint_spacing_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_path_constraint_spacing_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_path_constraint_spacing_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_path_constraint_spacing_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_path_constraint_spacing_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_path_constraint_spacing_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_path_constraint_spacing_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_path_constraint_spacing_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_path_constraint_spacing_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_path_constraint_spacing_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_path_constraint_spacing_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_path_constraint_spacing_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_path_constraint_spacing_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_path_constraint_spacing_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_path_constraint_spacing_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_path_constraint_spacing_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PhysicsConstraint.swift

@@ -0,0 +1,132 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePhysicsConstraint)
+@objcMembers
+public final class PhysicsConstraint: PosedActive, Posed, Constraint {
+    internal let wrappee: spine_physics_constraint
+
+    internal init(_ wrappee: spine_physics_constraint) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(data: PhysicsConstraintData, skeleton: Skeleton) {
+        let ptr = spine_physics_constraint_create(data.wrappee, skeleton.wrappee)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_physics_constraint_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func update(skeleton: Skeleton, physics: Physics) {
+        spine_physics_constraint_update(wrappee, skeleton.wrappee, physics)
+    }
+
+    public func sort(skeleton: Skeleton) {
+        spine_physics_constraint_sort(wrappee, skeleton.wrappee)
+    }
+
+    public func isSourceActive() -> Bool {
+        return spine_physics_constraint_is_source_active(wrappee) != 0
+    }
+
+    public func copy(skeleton: Skeleton) -> PhysicsConstraint {
+        let result = spine_physics_constraint_copy(wrappee, skeleton.wrappee)
+        return PhysicsConstraint(result)
+    }
+
+    public func reset(skeleton: Skeleton) {
+        spine_physics_constraint_reset(wrappee, skeleton.wrappee)
+    }
+
+    public func translate(x: Float, y: Float) {
+        spine_physics_constraint_translate(wrappee, x, y)
+    }
+
+    public func rotate(x: Float, y: Float, degrees: Float) {
+        spine_physics_constraint_rotate(wrappee, x, y, degrees)
+    }
+
+    public func getBone() -> BonePose {
+        let result = spine_physics_constraint_get_bone(wrappee)
+        return BonePose(result)
+    }
+
+    public func setBone(bone: BonePose) {
+        spine_physics_constraint_set_bone(wrappee, bone.wrappee)
+    }
+
+    public func getData() -> PhysicsConstraintData {
+        let result = spine_physics_constraint_get_data(wrappee)
+        return PhysicsConstraintData(result)
+    }
+
+    public func getPose() -> PhysicsConstraintPose {
+        let result = spine_physics_constraint_get_pose(wrappee)
+        return PhysicsConstraintPose(result)
+    }
+
+    public func getAppliedPose() -> PhysicsConstraintPose {
+        let result = spine_physics_constraint_get_applied_pose(wrappee)
+        return PhysicsConstraintPose(result)
+    }
+
+    public func resetConstrained() {
+        spine_physics_constraint_reset_constrained(wrappee)
+    }
+
+    public func constrained() {
+        spine_physics_constraint_constrained(wrappee)
+    }
+
+    public func isPoseEqualToApplied() -> Bool {
+        return spine_physics_constraint_is_pose_equal_to_applied(wrappee) != 0
+    }
+
+    public func isActive() -> Bool {
+        return spine_physics_constraint_is_active(wrappee) != 0
+    }
+
+    public func setActive(active: Bool) {
+        spine_physics_constraint_set_active(wrappee, active ? 1 : 0)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_physics_constraint_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_physics_constraint_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PhysicsConstraintDampingTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePhysicsConstraintDampingTimeline)
+@objcMembers
+public final class PhysicsConstraintDampingTimeline: PhysicsConstraintTimeline {
+    internal let wrappee: spine_physics_constraint_damping_timeline
+
+    internal init(_ wrappee: spine_physics_constraint_damping_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, physicsConstraintIndex: Int32) {
+        let ptr = spine_physics_constraint_damping_timeline_create(frameCount, bezierCount, physicsConstraintIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_physics_constraint_damping_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_physics_constraint_damping_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_physics_constraint_damping_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_physics_constraint_damping_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_physics_constraint_damping_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_physics_constraint_damping_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_damping_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_damping_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_physics_constraint_damping_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_damping_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_physics_constraint_damping_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_physics_constraint_damping_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_physics_constraint_damping_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_physics_constraint_damping_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_physics_constraint_damping_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_physics_constraint_damping_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_physics_constraint_damping_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_physics_constraint_damping_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_physics_constraint_damping_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_physics_constraint_damping_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_physics_constraint_damping_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_physics_constraint_damping_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PhysicsConstraintData.swift

@@ -0,0 +1,203 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePhysicsConstraintData)
+@objcMembers
+public final class PhysicsConstraintData: PosedData, ConstraintData {
+    internal let wrappee: spine_physics_constraint_data
+
+    internal init(_ wrappee: spine_physics_constraint_data) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(name: String?) {
+        let ptr = spine_physics_constraint_data_create(name)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_physics_constraint_data_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func createMethod(skeleton: Skeleton) -> Constraint {
+        let result = spine_physics_constraint_data_create_method(wrappee, skeleton.wrappee)
+        return Constraint(result)
+    }
+
+    public func getBone() -> BoneData {
+        let result = spine_physics_constraint_data_get_bone(wrappee)
+        return BoneData(result)
+    }
+
+    public func setBone(bone: BoneData) {
+        spine_physics_constraint_data_set_bone(wrappee, bone.wrappee)
+    }
+
+    public func getStep() -> Float {
+        return spine_physics_constraint_data_get_step(wrappee)
+    }
+
+    public func setStep(step: Float) {
+        spine_physics_constraint_data_set_step(wrappee, step)
+    }
+
+    public func getX() -> Float {
+        return spine_physics_constraint_data_get_x(wrappee)
+    }
+
+    public func setX(x: Float) {
+        spine_physics_constraint_data_set_x(wrappee, x)
+    }
+
+    public func getY() -> Float {
+        return spine_physics_constraint_data_get_y(wrappee)
+    }
+
+    public func setY(y: Float) {
+        spine_physics_constraint_data_set_y(wrappee, y)
+    }
+
+    public func getRotate() -> Float {
+        return spine_physics_constraint_data_get_rotate(wrappee)
+    }
+
+    public func setRotate(rotate: Float) {
+        spine_physics_constraint_data_set_rotate(wrappee, rotate)
+    }
+
+    public func getScaleX() -> Float {
+        return spine_physics_constraint_data_get_scale_x(wrappee)
+    }
+
+    public func setScaleX(scaleX: Float) {
+        spine_physics_constraint_data_set_scale_x(wrappee, scaleX)
+    }
+
+    public func getShearX() -> Float {
+        return spine_physics_constraint_data_get_shear_x(wrappee)
+    }
+
+    public func setShearX(shearX: Float) {
+        spine_physics_constraint_data_set_shear_x(wrappee, shearX)
+    }
+
+    public func getLimit() -> Float {
+        return spine_physics_constraint_data_get_limit(wrappee)
+    }
+
+    public func setLimit(limit: Float) {
+        spine_physics_constraint_data_set_limit(wrappee, limit)
+    }
+
+    public func getInertiaGlobal() -> Bool {
+        return spine_physics_constraint_data_get_inertia_global(wrappee) != 0
+    }
+
+    public func setInertiaGlobal(inertiaGlobal: Bool) {
+        spine_physics_constraint_data_set_inertia_global(wrappee, inertiaGlobal ? 1 : 0)
+    }
+
+    public func getStrengthGlobal() -> Bool {
+        return spine_physics_constraint_data_get_strength_global(wrappee) != 0
+    }
+
+    public func setStrengthGlobal(strengthGlobal: Bool) {
+        spine_physics_constraint_data_set_strength_global(wrappee, strengthGlobal ? 1 : 0)
+    }
+
+    public func getDampingGlobal() -> Bool {
+        return spine_physics_constraint_data_get_damping_global(wrappee) != 0
+    }
+
+    public func setDampingGlobal(dampingGlobal: Bool) {
+        spine_physics_constraint_data_set_damping_global(wrappee, dampingGlobal ? 1 : 0)
+    }
+
+    public func getMassGlobal() -> Bool {
+        return spine_physics_constraint_data_get_mass_global(wrappee) != 0
+    }
+
+    public func setMassGlobal(massGlobal: Bool) {
+        spine_physics_constraint_data_set_mass_global(wrappee, massGlobal ? 1 : 0)
+    }
+
+    public func getWindGlobal() -> Bool {
+        return spine_physics_constraint_data_get_wind_global(wrappee) != 0
+    }
+
+    public func setWindGlobal(windGlobal: Bool) {
+        spine_physics_constraint_data_set_wind_global(wrappee, windGlobal ? 1 : 0)
+    }
+
+    public func getGravityGlobal() -> Bool {
+        return spine_physics_constraint_data_get_gravity_global(wrappee) != 0
+    }
+
+    public func setGravityGlobal(gravityGlobal: Bool) {
+        spine_physics_constraint_data_set_gravity_global(wrappee, gravityGlobal ? 1 : 0)
+    }
+
+    public func getMixGlobal() -> Bool {
+        return spine_physics_constraint_data_get_mix_global(wrappee) != 0
+    }
+
+    public func setMixGlobal(mixGlobal: Bool) {
+        spine_physics_constraint_data_set_mix_global(wrappee, mixGlobal ? 1 : 0)
+    }
+
+    public func getName() -> String? {
+        let result = spine_physics_constraint_data_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getSkinRequired() -> Bool {
+        return spine_physics_constraint_data_get_skin_required(wrappee) != 0
+    }
+
+    public func getSetupPose() -> PhysicsConstraintPose {
+        let result = spine_physics_constraint_data_get_setup_pose(wrappee)
+        return PhysicsConstraintPose(result)
+    }
+
+    public func setSkinRequired(skinRequired: Bool) {
+        spine_physics_constraint_data_set_skin_required(wrappee, skinRequired ? 1 : 0)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_physics_constraint_data_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_physics_constraint_data_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PhysicsConstraintGravityTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePhysicsConstraintGravityTimeline)
+@objcMembers
+public final class PhysicsConstraintGravityTimeline: PhysicsConstraintTimeline {
+    internal let wrappee: spine_physics_constraint_gravity_timeline
+
+    internal init(_ wrappee: spine_physics_constraint_gravity_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, physicsConstraintIndex: Int32) {
+        let ptr = spine_physics_constraint_gravity_timeline_create(frameCount, bezierCount, physicsConstraintIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_physics_constraint_gravity_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_physics_constraint_gravity_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_physics_constraint_gravity_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_physics_constraint_gravity_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_physics_constraint_gravity_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_physics_constraint_gravity_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_gravity_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_gravity_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_physics_constraint_gravity_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_gravity_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_physics_constraint_gravity_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_physics_constraint_gravity_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_physics_constraint_gravity_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_physics_constraint_gravity_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_physics_constraint_gravity_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_physics_constraint_gravity_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_physics_constraint_gravity_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_physics_constraint_gravity_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_physics_constraint_gravity_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_physics_constraint_gravity_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_physics_constraint_gravity_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_physics_constraint_gravity_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PhysicsConstraintInertiaTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePhysicsConstraintInertiaTimeline)
+@objcMembers
+public final class PhysicsConstraintInertiaTimeline: PhysicsConstraintTimeline {
+    internal let wrappee: spine_physics_constraint_inertia_timeline
+
+    internal init(_ wrappee: spine_physics_constraint_inertia_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, physicsConstraintIndex: Int32) {
+        let ptr = spine_physics_constraint_inertia_timeline_create(frameCount, bezierCount, physicsConstraintIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_physics_constraint_inertia_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_physics_constraint_inertia_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_physics_constraint_inertia_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_physics_constraint_inertia_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_physics_constraint_inertia_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_physics_constraint_inertia_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_inertia_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_inertia_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_physics_constraint_inertia_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_inertia_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_physics_constraint_inertia_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_physics_constraint_inertia_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_physics_constraint_inertia_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_physics_constraint_inertia_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_physics_constraint_inertia_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_physics_constraint_inertia_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_physics_constraint_inertia_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_physics_constraint_inertia_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_physics_constraint_inertia_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_physics_constraint_inertia_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_physics_constraint_inertia_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_physics_constraint_inertia_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PhysicsConstraintMassTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePhysicsConstraintMassTimeline)
+@objcMembers
+public final class PhysicsConstraintMassTimeline: PhysicsConstraintTimeline {
+    internal let wrappee: spine_physics_constraint_mass_timeline
+
+    internal init(_ wrappee: spine_physics_constraint_mass_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, physicsConstraintIndex: Int32) {
+        let ptr = spine_physics_constraint_mass_timeline_create(frameCount, bezierCount, physicsConstraintIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_physics_constraint_mass_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_physics_constraint_mass_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_physics_constraint_mass_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_physics_constraint_mass_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_physics_constraint_mass_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_physics_constraint_mass_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_mass_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_mass_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_physics_constraint_mass_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_mass_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_physics_constraint_mass_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_physics_constraint_mass_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_physics_constraint_mass_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_physics_constraint_mass_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_physics_constraint_mass_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_physics_constraint_mass_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_physics_constraint_mass_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_physics_constraint_mass_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_physics_constraint_mass_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_physics_constraint_mass_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_physics_constraint_mass_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_physics_constraint_mass_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PhysicsConstraintMixTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePhysicsConstraintMixTimeline)
+@objcMembers
+public final class PhysicsConstraintMixTimeline: PhysicsConstraintTimeline {
+    internal let wrappee: spine_physics_constraint_mix_timeline
+
+    internal init(_ wrappee: spine_physics_constraint_mix_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, physicsConstraintIndex: Int32) {
+        let ptr = spine_physics_constraint_mix_timeline_create(frameCount, bezierCount, physicsConstraintIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_physics_constraint_mix_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_physics_constraint_mix_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_physics_constraint_mix_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_physics_constraint_mix_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_physics_constraint_mix_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_physics_constraint_mix_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_mix_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_mix_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_physics_constraint_mix_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_mix_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_physics_constraint_mix_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_physics_constraint_mix_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_physics_constraint_mix_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_physics_constraint_mix_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_physics_constraint_mix_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_physics_constraint_mix_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_physics_constraint_mix_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_physics_constraint_mix_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_physics_constraint_mix_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_physics_constraint_mix_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_physics_constraint_mix_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_physics_constraint_mix_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PhysicsConstraintPose.swift

@@ -0,0 +1,120 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePhysicsConstraintPose)
+@objcMembers
+public final class PhysicsConstraintPose: NSObject {
+    internal let wrappee: spine_physics_constraint_pose
+
+    internal init(_ wrappee: spine_physics_constraint_pose) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? PhysicsConstraintPose else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init() {
+        let ptr = spine_physics_constraint_pose_create()
+        self.init(ptr)
+    }
+
+    public func set(pose: PhysicsConstraintPose) {
+        spine_physics_constraint_pose_set(wrappee, pose.wrappee)
+    }
+
+    public func getInertia() -> Float {
+        return spine_physics_constraint_pose_get_inertia(wrappee)
+    }
+
+    public func setInertia(inertia: Float) {
+        spine_physics_constraint_pose_set_inertia(wrappee, inertia)
+    }
+
+    public func getStrength() -> Float {
+        return spine_physics_constraint_pose_get_strength(wrappee)
+    }
+
+    public func setStrength(strength: Float) {
+        spine_physics_constraint_pose_set_strength(wrappee, strength)
+    }
+
+    public func getDamping() -> Float {
+        return spine_physics_constraint_pose_get_damping(wrappee)
+    }
+
+    public func setDamping(damping: Float) {
+        spine_physics_constraint_pose_set_damping(wrappee, damping)
+    }
+
+    public func getMassInverse() -> Float {
+        return spine_physics_constraint_pose_get_mass_inverse(wrappee)
+    }
+
+    public func setMassInverse(massInverse: Float) {
+        spine_physics_constraint_pose_set_mass_inverse(wrappee, massInverse)
+    }
+
+    public func getWind() -> Float {
+        return spine_physics_constraint_pose_get_wind(wrappee)
+    }
+
+    public func setWind(wind: Float) {
+        spine_physics_constraint_pose_set_wind(wrappee, wind)
+    }
+
+    public func getGravity() -> Float {
+        return spine_physics_constraint_pose_get_gravity(wrappee)
+    }
+
+    public func setGravity(gravity: Float) {
+        spine_physics_constraint_pose_set_gravity(wrappee, gravity)
+    }
+
+    public func getMix() -> Float {
+        return spine_physics_constraint_pose_get_mix(wrappee)
+    }
+
+    public func setMix(mix: Float) {
+        spine_physics_constraint_pose_set_mix(wrappee, mix)
+    }
+
+    deinit {
+        spine_physics_constraint_pose_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PhysicsConstraintResetTimeline.swift

@@ -0,0 +1,95 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePhysicsConstraintResetTimeline)
+@objcMembers
+public final class PhysicsConstraintResetTimeline: Timeline, ConstraintTimeline {
+    internal let wrappee: spine_physics_constraint_reset_timeline
+
+    internal init(_ wrappee: spine_physics_constraint_reset_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, constraintIndex: Int32) {
+        let ptr = spine_physics_constraint_reset_timeline_create(frameCount, constraintIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_physics_constraint_reset_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_physics_constraint_reset_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getFrameCount() -> Int32 {
+        return spine_physics_constraint_reset_timeline_get_frame_count(wrappee)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_physics_constraint_reset_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_physics_constraint_reset_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: Int32, time: Float) {
+        spine_physics_constraint_reset_timeline_set_frame(wrappee, frame, time)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_physics_constraint_reset_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_physics_constraint_reset_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_physics_constraint_reset_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_physics_constraint_reset_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_physics_constraint_reset_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_physics_constraint_reset_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PhysicsConstraintStrengthTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePhysicsConstraintStrengthTimeline)
+@objcMembers
+public final class PhysicsConstraintStrengthTimeline: PhysicsConstraintTimeline {
+    internal let wrappee: spine_physics_constraint_strength_timeline
+
+    internal init(_ wrappee: spine_physics_constraint_strength_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, physicsConstraintIndex: Int32) {
+        let ptr = spine_physics_constraint_strength_timeline_create(frameCount, bezierCount, physicsConstraintIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_physics_constraint_strength_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_physics_constraint_strength_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_physics_constraint_strength_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_physics_constraint_strength_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_physics_constraint_strength_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_physics_constraint_strength_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_strength_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_strength_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_physics_constraint_strength_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_strength_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_physics_constraint_strength_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_physics_constraint_strength_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_physics_constraint_strength_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_physics_constraint_strength_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_physics_constraint_strength_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_physics_constraint_strength_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_physics_constraint_strength_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_physics_constraint_strength_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_physics_constraint_strength_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_physics_constraint_strength_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_physics_constraint_strength_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_physics_constraint_strength_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PhysicsConstraintTimeline.swift

@@ -0,0 +1,130 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePhysicsConstraintTimeline)
+@objcMembers
+public final class PhysicsConstraintTimeline: CurveTimeline1, ConstraintTimeline {
+    internal let wrappee: spine_physics_constraint_timeline
+
+    internal init(_ wrappee: spine_physics_constraint_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_physics_constraint_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_physics_constraint_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_physics_constraint_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_physics_constraint_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_physics_constraint_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_physics_constraint_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_physics_constraint_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_physics_constraint_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_physics_constraint_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_physics_constraint_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_physics_constraint_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_physics_constraint_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_physics_constraint_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_physics_constraint_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_physics_constraint_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_physics_constraint_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_physics_constraint_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_physics_constraint_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_physics_constraint_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PhysicsConstraintWindTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePhysicsConstraintWindTimeline)
+@objcMembers
+public final class PhysicsConstraintWindTimeline: PhysicsConstraintTimeline {
+    internal let wrappee: spine_physics_constraint_wind_timeline
+
+    internal init(_ wrappee: spine_physics_constraint_wind_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, physicsConstraintIndex: Int32) {
+        let ptr = spine_physics_constraint_wind_timeline_create(frameCount, bezierCount, physicsConstraintIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_physics_constraint_wind_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_physics_constraint_wind_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getConstraintIndex() -> Int32 {
+        return spine_physics_constraint_wind_timeline_get_constraint_index(wrappee)
+    }
+
+    public func setConstraintIndex(inValue: Int32) {
+        spine_physics_constraint_wind_timeline_set_constraint_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_physics_constraint_wind_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_physics_constraint_wind_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_wind_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_wind_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_physics_constraint_wind_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_physics_constraint_wind_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_physics_constraint_wind_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_physics_constraint_wind_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_physics_constraint_wind_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_physics_constraint_wind_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_physics_constraint_wind_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_physics_constraint_wind_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_physics_constraint_wind_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_physics_constraint_wind_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_physics_constraint_wind_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_physics_constraint_wind_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_physics_constraint_wind_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_physics_constraint_wind_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PointAttachment.swift

@@ -0,0 +1,118 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePointAttachment)
+@objcMembers
+public final class PointAttachment: Attachment {
+    internal let wrappee: spine_point_attachment
+
+    internal init(_ wrappee: spine_point_attachment) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(name: String?) {
+        let ptr = spine_point_attachment_create(name)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_point_attachment_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func getX() -> Float {
+        return spine_point_attachment_get_x(wrappee)
+    }
+
+    public func setX(inValue: Float) {
+        spine_point_attachment_set_x(wrappee, inValue)
+    }
+
+    public func getY() -> Float {
+        return spine_point_attachment_get_y(wrappee)
+    }
+
+    public func setY(inValue: Float) {
+        spine_point_attachment_set_y(wrappee, inValue)
+    }
+
+    public func getRotation() -> Float {
+        return spine_point_attachment_get_rotation(wrappee)
+    }
+
+    public func setRotation(inValue: Float) {
+        spine_point_attachment_set_rotation(wrappee, inValue)
+    }
+
+    public func getColor() -> Color {
+        let result = spine_point_attachment_get_color(wrappee)
+        return Color(result)
+    }
+
+    public func computeWorldPosition(bone: BonePose, ox: UnsafeMutablePointer<Float>?, oy: UnsafeMutablePointer<Float>?) {
+        spine_point_attachment_compute_world_position(wrappee, bone.wrappee, ox, oy)
+    }
+
+    public func computeWorldRotation(bone: BonePose) -> Float {
+        return spine_point_attachment_compute_world_rotation(wrappee, bone.wrappee)
+    }
+
+    public func copy() -> Attachment {
+        let result = spine_point_attachment_copy(wrappee)
+        return Attachment(result)
+    }
+
+    public func getName() -> String? {
+        let result = spine_point_attachment_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getRefCount() -> Int32 {
+        return spine_point_attachment_get_ref_count(wrappee)
+    }
+
+    public func reference() {
+        spine_point_attachment_reference(wrappee)
+    }
+
+    public func dereference() {
+        spine_point_attachment_dereference(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_point_attachment_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_point_attachment_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Polygon.swift

@@ -0,0 +1,76 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePolygon)
+@objcMembers
+public final class Polygon: NSObject {
+    internal let wrappee: spine_polygon
+
+    internal init(_ wrappee: spine_polygon) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? Polygon else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init() {
+        let ptr = spine_polygon_create()
+        self.init(ptr)
+    }
+
+    public func getVertices() -> ArrayFloat {
+        return spine_polygon_get__vertices(wrappee)
+    }
+
+    public func setVertices(value: ArrayFloat) {
+        spine_polygon_set__vertices(wrappee, value)
+    }
+
+    public func getCount() -> Int32 {
+        return spine_polygon_get__count(wrappee)
+    }
+
+    public func setCount(value: Int32) {
+        spine_polygon_set__count(wrappee, value)
+    }
+
+    deinit {
+        spine_polygon_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Posed.swift

@@ -0,0 +1,67 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePosed)
+@objcMembers
+public final class Posed {
+    internal let wrappee: spine_posed
+
+    internal init(_ wrappee: spine_posed) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? Posed else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public func constrained() {
+        spine_posed_constrained(wrappee)
+    }
+
+    public func resetConstrained() {
+        spine_posed_reset_constrained(wrappee)
+    }
+
+    public func isPoseEqualToApplied() -> Bool {
+        return spine_posed_is_pose_equal_to_applied(wrappee) != 0
+    }
+
+    deinit {
+        spine_posed_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PosedActive.swift

@@ -0,0 +1,63 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePosedActive)
+@objcMembers
+public final class PosedActive: NSObject {
+    internal let wrappee: spine_posed_active
+
+    internal init(_ wrappee: spine_posed_active) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? PosedActive else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public func isActive() -> Bool {
+        return spine_posed_active_is_active(wrappee) != 0
+    }
+
+    public func setActive(active: Bool) {
+        spine_posed_active_set_active(wrappee, active ? 1 : 0)
+    }
+
+    deinit {
+        spine_posed_active_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/PosedData.swift

@@ -0,0 +1,73 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpinePosedData)
+@objcMembers
+public final class PosedData: NSObject {
+    internal let wrappee: spine_posed_data
+
+    internal init(_ wrappee: spine_posed_data) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? PosedData else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(name: String?) {
+        let ptr = spine_posed_data_create(name)
+        self.init(ptr)
+    }
+
+    public func getName() -> String? {
+        let result = spine_posed_data_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getSkinRequired() -> Bool {
+        return spine_posed_data_get_skin_required(wrappee) != 0
+    }
+
+    public func setSkinRequired(skinRequired: Bool) {
+        spine_posed_data_set_skin_required(wrappee, skinRequired ? 1 : 0)
+    }
+
+    deinit {
+        spine_posed_data_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/RegionAttachment.swift

@@ -0,0 +1,189 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineRegionAttachment)
+@objcMembers
+public final class RegionAttachment: Attachment {
+    internal let wrappee: spine_region_attachment
+
+    internal init(_ wrappee: spine_region_attachment) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(name: String?) {
+        let ptr = spine_region_attachment_create(name)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_region_attachment_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func updateRegion() {
+        spine_region_attachment_update_region(wrappee)
+    }
+
+    public func computeWorldVertices(slot: Slot, worldVertices: UnsafeMutablePointer<Float>?, offset: size_t, stride: size_t) {
+        spine_region_attachment_compute_world_vertices_1(wrappee, slot.wrappee, worldVertices, offset, stride)
+    }
+
+    public func computeWorldVertices(slot: Slot, worldVertices: ArrayFloat, offset: size_t, stride: size_t) {
+        spine_region_attachment_compute_world_vertices_2(wrappee, slot.wrappee, worldVertices, offset, stride)
+    }
+
+    public func getX() -> Float {
+        return spine_region_attachment_get_x(wrappee)
+    }
+
+    public func setX(inValue: Float) {
+        spine_region_attachment_set_x(wrappee, inValue)
+    }
+
+    public func getY() -> Float {
+        return spine_region_attachment_get_y(wrappee)
+    }
+
+    public func setY(inValue: Float) {
+        spine_region_attachment_set_y(wrappee, inValue)
+    }
+
+    public func getRotation() -> Float {
+        return spine_region_attachment_get_rotation(wrappee)
+    }
+
+    public func setRotation(inValue: Float) {
+        spine_region_attachment_set_rotation(wrappee, inValue)
+    }
+
+    public func getScaleX() -> Float {
+        return spine_region_attachment_get_scale_x(wrappee)
+    }
+
+    public func setScaleX(inValue: Float) {
+        spine_region_attachment_set_scale_x(wrappee, inValue)
+    }
+
+    public func getScaleY() -> Float {
+        return spine_region_attachment_get_scale_y(wrappee)
+    }
+
+    public func setScaleY(inValue: Float) {
+        spine_region_attachment_set_scale_y(wrappee, inValue)
+    }
+
+    public func getWidth() -> Float {
+        return spine_region_attachment_get_width(wrappee)
+    }
+
+    public func setWidth(inValue: Float) {
+        spine_region_attachment_set_width(wrappee, inValue)
+    }
+
+    public func getHeight() -> Float {
+        return spine_region_attachment_get_height(wrappee)
+    }
+
+    public func setHeight(inValue: Float) {
+        spine_region_attachment_set_height(wrappee, inValue)
+    }
+
+    public func getColor() -> Color {
+        let result = spine_region_attachment_get_color(wrappee)
+        return Color(result)
+    }
+
+    public func getPath() -> String? {
+        let result = spine_region_attachment_get_path(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func setPath(inValue: String?) {
+        spine_region_attachment_set_path(wrappee, inValue?.cString(using: .utf8))
+    }
+
+    public func getRegion() -> TextureRegion {
+        let result = spine_region_attachment_get_region(wrappee)
+        return TextureRegion(result)
+    }
+
+    public func setRegion(region: TextureRegion) {
+        spine_region_attachment_set_region(wrappee, region.wrappee)
+    }
+
+    public func getSequence() -> Sequence {
+        let result = spine_region_attachment_get_sequence(wrappee)
+        return Sequence(result)
+    }
+
+    public func setSequence(sequence: Sequence) {
+        spine_region_attachment_set_sequence(wrappee, sequence.wrappee)
+    }
+
+    public func getOffset() -> ArrayFloat {
+        return spine_region_attachment_get_offset(wrappee)
+    }
+
+    public func getUVs() -> ArrayFloat {
+        return spine_region_attachment_get_u_vs(wrappee)
+    }
+
+    public func copy() -> Attachment {
+        let result = spine_region_attachment_copy(wrappee)
+        return Attachment(result)
+    }
+
+    public func getName() -> String? {
+        let result = spine_region_attachment_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getRefCount() -> Int32 {
+        return spine_region_attachment_get_ref_count(wrappee)
+    }
+
+    public func reference() {
+        spine_region_attachment_reference(wrappee)
+    }
+
+    public func dereference() {
+        spine_region_attachment_dereference(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_region_attachment_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_region_attachment_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/RenderCommand.swift

@@ -0,0 +1,96 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineRenderCommand)
+@objcMembers
+public final class RenderCommand: NSObject {
+    internal let wrappee: spine_render_command
+
+    internal init(_ wrappee: spine_render_command) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? RenderCommand else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public func getPositions() -> UnsafeMutablePointer<Float>? {
+        return spine_render_command_get_positions(wrappee)
+    }
+
+    public func getUvs() -> UnsafeMutablePointer<Float>? {
+        return spine_render_command_get_uvs(wrappee)
+    }
+
+    public func getColors() -> OpaquePointer? {
+        return spine_render_command_get_colors(wrappee)
+    }
+
+    public func getDarkColors() -> OpaquePointer? {
+        return spine_render_command_get_dark_colors(wrappee)
+    }
+
+    public func getNumVertices() -> Int32 {
+        return spine_render_command_get_num_vertices(wrappee)
+    }
+
+    public func getIndices() -> OpaquePointer? {
+        return spine_render_command_get_indices(wrappee)
+    }
+
+    public func getNumIndices() -> Int32 {
+        return spine_render_command_get_num_indices(wrappee)
+    }
+
+    public func getBlendMode() -> BlendMode {
+        return spine_render_command_get_blend_mode(wrappee)
+    }
+
+    public func getTexture() -> OpaquePointer? {
+        return spine_render_command_get_texture(wrappee)
+    }
+
+    public func getNext() -> RenderCommand {
+        let result = spine_render_command_get_next(wrappee)
+        return RenderCommand(result)
+    }
+
+    deinit {
+        spine_render_command_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Rgb2Timeline.swift

@@ -0,0 +1,115 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineRgb2Timeline)
+@objcMembers
+public final class Rgb2Timeline: SlotCurveTimeline {
+    internal let wrappee: spine_rgb2_timeline
+
+    internal init(_ wrappee: spine_rgb2_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, slotIndex: Int32) {
+        let ptr = spine_rgb2_timeline_create(frameCount, bezierCount, slotIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_rgb2_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func setFrame(frame: Int32, time: Float, r: Float, g: Float, b: Float, r2: Float, g2: Float, b2: Float) {
+        spine_rgb2_timeline_set_frame(wrappee, frame, time, r, g, b, r2, g2, b2)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_rgb2_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getSlotIndex() -> Int32 {
+        return spine_rgb2_timeline_get_slot_index(wrappee)
+    }
+
+    public func setSlotIndex(inValue: Int32) {
+        spine_rgb2_timeline_set_slot_index(wrappee, inValue)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_rgb2_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_rgb2_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_rgb2_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_rgb2_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_rgb2_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_rgb2_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_rgb2_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_rgb2_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_rgb2_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_rgb2_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_rgb2_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_rgb2_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/RgbTimeline.swift

@@ -0,0 +1,115 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineRgbTimeline)
+@objcMembers
+public final class RgbTimeline: SlotCurveTimeline {
+    internal let wrappee: spine_rgb_timeline
+
+    internal init(_ wrappee: spine_rgb_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, slotIndex: Int32) {
+        let ptr = spine_rgb_timeline_create(frameCount, bezierCount, slotIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_rgb_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func setFrame(frame: Int32, time: Float, r: Float, g: Float, b: Float) {
+        spine_rgb_timeline_set_frame(wrappee, frame, time, r, g, b)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_rgb_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getSlotIndex() -> Int32 {
+        return spine_rgb_timeline_get_slot_index(wrappee)
+    }
+
+    public func setSlotIndex(inValue: Int32) {
+        spine_rgb_timeline_set_slot_index(wrappee, inValue)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_rgb_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_rgb_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_rgb_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_rgb_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_rgb_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_rgb_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_rgb_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_rgb_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_rgb_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_rgb_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_rgb_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_rgb_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Rgba2Timeline.swift

@@ -0,0 +1,115 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineRgba2Timeline)
+@objcMembers
+public final class Rgba2Timeline: SlotCurveTimeline {
+    internal let wrappee: spine_rgba2_timeline
+
+    internal init(_ wrappee: spine_rgba2_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, slotIndex: Int32) {
+        let ptr = spine_rgba2_timeline_create(frameCount, bezierCount, slotIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_rgba2_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func setFrame(frame: Int32, time: Float, r: Float, g: Float, b: Float, a: Float, r2: Float, g2: Float, b2: Float) {
+        spine_rgba2_timeline_set_frame(wrappee, frame, time, r, g, b, a, r2, g2, b2)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_rgba2_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getSlotIndex() -> Int32 {
+        return spine_rgba2_timeline_get_slot_index(wrappee)
+    }
+
+    public func setSlotIndex(inValue: Int32) {
+        spine_rgba2_timeline_set_slot_index(wrappee, inValue)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_rgba2_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_rgba2_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_rgba2_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_rgba2_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_rgba2_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_rgba2_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_rgba2_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_rgba2_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_rgba2_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_rgba2_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_rgba2_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_rgba2_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/RgbaTimeline.swift

@@ -0,0 +1,115 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineRgbaTimeline)
+@objcMembers
+public final class RgbaTimeline: SlotCurveTimeline {
+    internal let wrappee: spine_rgba_timeline
+
+    internal init(_ wrappee: spine_rgba_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, slotIndex: Int32) {
+        let ptr = spine_rgba_timeline_create(frameCount, bezierCount, slotIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_rgba_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func setFrame(frame: Int32, time: Float, r: Float, g: Float, b: Float, a: Float) {
+        spine_rgba_timeline_set_frame(wrappee, frame, time, r, g, b, a)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_rgba_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getSlotIndex() -> Int32 {
+        return spine_rgba_timeline_get_slot_index(wrappee)
+    }
+
+    public func setSlotIndex(inValue: Int32) {
+        spine_rgba_timeline_set_slot_index(wrappee, inValue)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_rgba_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_rgba_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_rgba_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_rgba_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_rgba_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_rgba_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_rgba_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_rgba_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_rgba_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_rgba_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_rgba_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_rgba_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/RotateTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineRotateTimeline)
+@objcMembers
+public final class RotateTimeline: BoneTimeline1 {
+    internal let wrappee: spine_rotate_timeline
+
+    internal init(_ wrappee: spine_rotate_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, boneIndex: Int32) {
+        let ptr = spine_rotate_timeline_create(frameCount, bezierCount, boneIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_rotate_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_rotate_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getBoneIndex() -> Int32 {
+        return spine_rotate_timeline_get_bone_index(wrappee)
+    }
+
+    public func setBoneIndex(inValue: Int32) {
+        spine_rotate_timeline_set_bone_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_rotate_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_rotate_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_rotate_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_rotate_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_rotate_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_rotate_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_rotate_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_rotate_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_rotate_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_rotate_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_rotate_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_rotate_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_rotate_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_rotate_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_rotate_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_rotate_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_rotate_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_rotate_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Rtti.swift

@@ -0,0 +1,68 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineRtti)
+@objcMembers
+public final class Rtti: NSObject {
+    internal let wrappee: spine_rtti
+
+    internal init(_ wrappee: spine_rtti) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? Rtti else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public func getClassName() -> String? {
+        let result = spine_rtti_get_class_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func isExactly(rtti: Rtti) -> Bool {
+        return spine_rtti_is_exactly(wrappee, rtti.wrappee) != 0
+    }
+
+    public func instanceOf(rtti: Rtti) -> Bool {
+        return spine_rtti_instance_of(wrappee, rtti.wrappee) != 0
+    }
+
+    deinit {
+        spine_rtti_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/ScaleTimeline.swift

@@ -0,0 +1,115 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineScaleTimeline)
+@objcMembers
+public final class ScaleTimeline: BoneTimeline2 {
+    internal let wrappee: spine_scale_timeline
+
+    internal init(_ wrappee: spine_scale_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, boneIndex: Int32) {
+        let ptr = spine_scale_timeline_create(frameCount, bezierCount, boneIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_scale_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_scale_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getBoneIndex() -> Int32 {
+        return spine_scale_timeline_get_bone_index(wrappee)
+    }
+
+    public func setBoneIndex(inValue: Int32) {
+        spine_scale_timeline_set_bone_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value1: Float, value2: Float) {
+        spine_scale_timeline_set_frame(wrappee, frame, time, value1, value2)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_scale_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_scale_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_scale_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_scale_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_scale_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_scale_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_scale_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_scale_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_scale_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_scale_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_scale_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_scale_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/ScaleXTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineScaleXTimeline)
+@objcMembers
+public final class ScaleXTimeline: BoneTimeline1 {
+    internal let wrappee: spine_scale_x_timeline
+
+    internal init(_ wrappee: spine_scale_x_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, boneIndex: Int32) {
+        let ptr = spine_scale_x_timeline_create(frameCount, bezierCount, boneIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_scale_x_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_scale_x_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getBoneIndex() -> Int32 {
+        return spine_scale_x_timeline_get_bone_index(wrappee)
+    }
+
+    public func setBoneIndex(inValue: Int32) {
+        spine_scale_x_timeline_set_bone_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_scale_x_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_scale_x_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_scale_x_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_scale_x_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_scale_x_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_scale_x_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_scale_x_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_scale_x_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_scale_x_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_scale_x_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_scale_x_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_scale_x_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_scale_x_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_scale_x_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_scale_x_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_scale_x_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_scale_x_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_scale_x_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/ScaleYTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineScaleYTimeline)
+@objcMembers
+public final class ScaleYTimeline: BoneTimeline1 {
+    internal let wrappee: spine_scale_y_timeline
+
+    internal init(_ wrappee: spine_scale_y_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, boneIndex: Int32) {
+        let ptr = spine_scale_y_timeline_create(frameCount, bezierCount, boneIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_scale_y_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_scale_y_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getBoneIndex() -> Int32 {
+        return spine_scale_y_timeline_get_bone_index(wrappee)
+    }
+
+    public func setBoneIndex(inValue: Int32) {
+        spine_scale_y_timeline_set_bone_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_scale_y_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_scale_y_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_scale_y_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_scale_y_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_scale_y_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_scale_y_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_scale_y_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_scale_y_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_scale_y_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_scale_y_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_scale_y_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_scale_y_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_scale_y_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_scale_y_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_scale_y_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_scale_y_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_scale_y_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_scale_y_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Sequence.swift

@@ -0,0 +1,110 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineSequence)
+@objcMembers
+public final class Sequence: NSObject {
+    internal let wrappee: spine_sequence
+
+    internal init(_ wrappee: spine_sequence) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? Sequence else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(count: Int32) {
+        let ptr = spine_sequence_create(count)
+        self.init(ptr)
+    }
+
+    public func copy() -> Sequence {
+        let result = spine_sequence_copy(wrappee)
+        return Sequence(result)
+    }
+
+    public func apply(slot: SlotPose, attachment: Attachment) {
+        spine_sequence_apply(wrappee, slot.wrappee, attachment.wrappee)
+    }
+
+    public func getPath(basePath: String?, index: Int32) -> String? {
+        let result = spine_sequence_get_path(wrappee, basePath?.cString(using: .utf8), index)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func getId() -> Int32 {
+        return spine_sequence_get_id(wrappee)
+    }
+
+    public func setId(id: Int32) {
+        spine_sequence_set_id(wrappee, id)
+    }
+
+    public func getStart() -> Int32 {
+        return spine_sequence_get_start(wrappee)
+    }
+
+    public func setStart(start: Int32) {
+        spine_sequence_set_start(wrappee, start)
+    }
+
+    public func getDigits() -> Int32 {
+        return spine_sequence_get_digits(wrappee)
+    }
+
+    public func setDigits(digits: Int32) {
+        spine_sequence_set_digits(wrappee, digits)
+    }
+
+    public func getSetupIndex() -> Int32 {
+        return spine_sequence_get_setup_index(wrappee)
+    }
+
+    public func setSetupIndex(setupIndex: Int32) {
+        spine_sequence_set_setup_index(wrappee, setupIndex)
+    }
+
+    public func getRegions() -> ArrayTextureRegion {
+        return spine_sequence_get_regions(wrappee)
+    }
+
+    deinit {
+        spine_sequence_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/SequenceTimeline.swift

@@ -0,0 +1,100 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineSequenceTimeline)
+@objcMembers
+public final class SequenceTimeline: Timeline, SlotTimeline {
+    internal let wrappee: spine_sequence_timeline
+
+    internal init(_ wrappee: spine_sequence_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, slotIndex: Int32, attachment: Attachment) {
+        let ptr = spine_sequence_timeline_create(frameCount, slotIndex, attachment.wrappee)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_sequence_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_sequence_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func setFrame(frame: Int32, time: Float, mode: SequenceMode, index: Int32, delay: Float) {
+        spine_sequence_timeline_set_frame(wrappee, frame, time, mode, index, delay)
+    }
+
+    public func getAttachment() -> Attachment {
+        let result = spine_sequence_timeline_get_attachment(wrappee)
+        return Attachment(result)
+    }
+
+    public func getSlotIndex() -> Int32 {
+        return spine_sequence_timeline_get_slot_index(wrappee)
+    }
+
+    public func setSlotIndex(inValue: Int32) {
+        spine_sequence_timeline_set_slot_index(wrappee, inValue)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_sequence_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_sequence_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_sequence_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_sequence_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_sequence_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_sequence_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_sequence_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/ShearTimeline.swift

@@ -0,0 +1,115 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineShearTimeline)
+@objcMembers
+public final class ShearTimeline: BoneTimeline2 {
+    internal let wrappee: spine_shear_timeline
+
+    internal init(_ wrappee: spine_shear_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, boneIndex: Int32) {
+        let ptr = spine_shear_timeline_create(frameCount, bezierCount, boneIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_shear_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_shear_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getBoneIndex() -> Int32 {
+        return spine_shear_timeline_get_bone_index(wrappee)
+    }
+
+    public func setBoneIndex(inValue: Int32) {
+        spine_shear_timeline_set_bone_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value1: Float, value2: Float) {
+        spine_shear_timeline_set_frame(wrappee, frame, time, value1, value2)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_shear_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_shear_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_shear_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_shear_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_shear_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_shear_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_shear_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_shear_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_shear_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_shear_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_shear_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_shear_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/ShearXTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineShearXTimeline)
+@objcMembers
+public final class ShearXTimeline: BoneTimeline1 {
+    internal let wrappee: spine_shear_x_timeline
+
+    internal init(_ wrappee: spine_shear_x_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, boneIndex: Int32) {
+        let ptr = spine_shear_x_timeline_create(frameCount, bezierCount, boneIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_shear_x_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_shear_x_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getBoneIndex() -> Int32 {
+        return spine_shear_x_timeline_get_bone_index(wrappee)
+    }
+
+    public func setBoneIndex(inValue: Int32) {
+        spine_shear_x_timeline_set_bone_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_shear_x_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_shear_x_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_shear_x_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_shear_x_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_shear_x_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_shear_x_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_shear_x_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_shear_x_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_shear_x_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_shear_x_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_shear_x_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_shear_x_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_shear_x_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_shear_x_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_shear_x_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_shear_x_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_shear_x_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_shear_x_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/ShearYTimeline.swift

@@ -0,0 +1,135 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineShearYTimeline)
+@objcMembers
+public final class ShearYTimeline: BoneTimeline1 {
+    internal let wrappee: spine_shear_y_timeline
+
+    internal init(_ wrappee: spine_shear_y_timeline) {
+        self.wrappee = wrappee
+        super.init(wrappee)
+    }
+
+    public convenience init(frameCount: size_t, bezierCount: size_t, boneIndex: Int32) {
+        let ptr = spine_shear_y_timeline_create(frameCount, bezierCount, boneIndex)
+        self.init(ptr)
+    }
+
+    public func getRtti() -> Rtti {
+        let result = spine_shear_y_timeline_get_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    public func apply(skeleton: Skeleton, lastTime: Float, time: Float, events: ArrayEvent, alpha: Float, blend: MixBlend, direction: MixDirection, appliedPose: Bool) {
+        spine_shear_y_timeline_apply(wrappee, skeleton.wrappee, lastTime, time, events, alpha, blend, direction, appliedPose ? 1 : 0)
+    }
+
+    public func getBoneIndex() -> Int32 {
+        return spine_shear_y_timeline_get_bone_index(wrappee)
+    }
+
+    public func setBoneIndex(inValue: Int32) {
+        spine_shear_y_timeline_set_bone_index(wrappee, inValue)
+    }
+
+    public func setFrame(frame: size_t, time: Float, value: Float) {
+        spine_shear_y_timeline_set_frame(wrappee, frame, time, value)
+    }
+
+    public func getCurveValue(time: Float) -> Float {
+        return spine_shear_y_timeline_get_curve_value(wrappee, time)
+    }
+
+    public func getRelativeValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_shear_y_timeline_get_relative_value(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float) -> Float {
+        return spine_shear_y_timeline_get_absolute_value_1(wrappee, time, alpha, blend, current, setup)
+    }
+
+    public func getAbsoluteValue(time: Float, alpha: Float, blend: MixBlend, current: Float, setup: Float, value: Float) -> Float {
+        return spine_shear_y_timeline_get_absolute_value_2(wrappee, time, alpha, blend, current, setup, value)
+    }
+
+    public func getScaleValue(time: Float, alpha: Float, blend: MixBlend, direction: MixDirection, current: Float, setup: Float) -> Float {
+        return spine_shear_y_timeline_get_scale_value(wrappee, time, alpha, blend, direction, current, setup)
+    }
+
+    public func setLinear(frame: size_t) {
+        spine_shear_y_timeline_set_linear(wrappee, frame)
+    }
+
+    public func setStepped(frame: size_t) {
+        spine_shear_y_timeline_set_stepped(wrappee, frame)
+    }
+
+    public func setBezier(bezier: size_t, frame: size_t, value: Float, time1: Float, value1: Float, cx1: Float, cy1: Float, cx2: Float, cy2: Float, time2: Float, value2: Float) {
+        spine_shear_y_timeline_set_bezier(wrappee, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2)
+    }
+
+    public func getBezierValue(time: Float, frame: size_t, valueOffset: size_t, i: size_t) -> Float {
+        return spine_shear_y_timeline_get_bezier_value(wrappee, time, frame, valueOffset, i)
+    }
+
+    public func getCurves() -> ArrayFloat {
+        return spine_shear_y_timeline_get_curves(wrappee)
+    }
+
+    public func getFrameEntries() -> size_t {
+        return spine_shear_y_timeline_get_frame_entries(wrappee)
+    }
+
+    public func getFrameCount() -> size_t {
+        return spine_shear_y_timeline_get_frame_count(wrappee)
+    }
+
+    public func getFrames() -> ArrayFloat {
+        return spine_shear_y_timeline_get_frames(wrappee)
+    }
+
+    public func getDuration() -> Float {
+        return spine_shear_y_timeline_get_duration(wrappee)
+    }
+
+    public func getPropertyIds() -> ArrayPropertyId {
+        return spine_shear_y_timeline_get_property_ids(wrappee)
+    }
+
+    public func rtti() -> Rtti {
+        let result = spine_shear_y_timeline_rtti(wrappee)
+        return Rtti(result)
+    }
+
+    deinit {
+        spine_shear_y_timeline_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Skeleton.swift

@@ -0,0 +1,284 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineSkeleton)
+@objcMembers
+public final class Skeleton: NSObject {
+    internal let wrappee: spine_skeleton
+
+    internal init(_ wrappee: spine_skeleton) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? Skeleton else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(skeletonData: SkeletonData) {
+        let ptr = spine_skeleton_create(skeletonData.wrappee)
+        self.init(ptr)
+    }
+
+    public func updateCache() {
+        spine_skeleton_update_cache(wrappee)
+    }
+
+    public func printUpdateCache() {
+        spine_skeleton_print_update_cache(wrappee)
+    }
+
+    public func constrained(object: Posed) {
+        spine_skeleton_constrained(wrappee, object.wrappee)
+    }
+
+    public func sortBone(bone: Bone) {
+        spine_skeleton_sort_bone(wrappee, bone.wrappee)
+    }
+
+    public func sortReset(bones: ArrayBone) {
+        spine_skeleton_sort_reset(wrappee, bones)
+    }
+
+    public func updateWorldTransform(physics: Physics) {
+        spine_skeleton_update_world_transform(wrappee, physics)
+    }
+
+    public func setupPose() {
+        spine_skeleton_setup_pose(wrappee)
+    }
+
+    public func setupPoseBones() {
+        spine_skeleton_setup_pose_bones(wrappee)
+    }
+
+    public func setupPoseSlots() {
+        spine_skeleton_setup_pose_slots(wrappee)
+    }
+
+    public func getData() -> SkeletonData {
+        let result = spine_skeleton_get_data(wrappee)
+        return SkeletonData(result)
+    }
+
+    public func getBones() -> ArrayBone {
+        return spine_skeleton_get_bones(wrappee)
+    }
+
+    public func getUpdateCache() -> ArrayUpdate {
+        return spine_skeleton_get_update_cache(wrappee)
+    }
+
+    public func getRootBone() -> Bone {
+        let result = spine_skeleton_get_root_bone(wrappee)
+        return Bone(result)
+    }
+
+    public func findBone(boneName: String?) -> Bone {
+        let result = spine_skeleton_find_bone(wrappee, boneName?.cString(using: .utf8))
+        return Bone(result)
+    }
+
+    public func getSlots() -> ArraySlot {
+        return spine_skeleton_get_slots(wrappee)
+    }
+
+    public func findSlot(slotName: String?) -> Slot {
+        let result = spine_skeleton_find_slot(wrappee, slotName?.cString(using: .utf8))
+        return Slot(result)
+    }
+
+    public func getDrawOrder() -> ArraySlot {
+        return spine_skeleton_get_draw_order(wrappee)
+    }
+
+    public func getSkin() -> Skin {
+        let result = spine_skeleton_get_skin(wrappee)
+        return Skin(result)
+    }
+
+    public func setSkin(skinName: String?) {
+        spine_skeleton_set_skin_1(wrappee, skinName?.cString(using: .utf8))
+    }
+
+    public func setSkin(newSkin: Skin) {
+        spine_skeleton_set_skin_2(wrappee, newSkin.wrappee)
+    }
+
+    public func getAttachment(slotName: String?, attachmentName: String?) -> Attachment {
+        let result = spine_skeleton_get_attachment_1(wrappee, slotName?.cString(using: .utf8), attachmentName?.cString(using: .utf8))
+        return Attachment(result)
+    }
+
+    public func getAttachment(slotIndex: Int32, attachmentName: String?) -> Attachment {
+        let result = spine_skeleton_get_attachment_2(wrappee, slotIndex, attachmentName?.cString(using: .utf8))
+        return Attachment(result)
+    }
+
+    public func setAttachment(slotName: String?, attachmentName: String?) {
+        spine_skeleton_set_attachment(wrappee, slotName?.cString(using: .utf8), attachmentName?.cString(using: .utf8))
+    }
+
+    public func getConstraints() -> ArrayConstraint {
+        return spine_skeleton_get_constraints(wrappee)
+    }
+
+    public func getPhysicsConstraints() -> ArrayPhysicsConstraint {
+        return spine_skeleton_get_physics_constraints(wrappee)
+    }
+
+    public func getBounds(outX: UnsafeMutablePointer<Float>?, outY: UnsafeMutablePointer<Float>?, outWidth: UnsafeMutablePointer<Float>?, outHeight: UnsafeMutablePointer<Float>?) {
+        spine_skeleton_get_bounds_1(wrappee, outX, outY, outWidth, outHeight)
+    }
+
+    public func getBounds(outX: UnsafeMutablePointer<Float>?, outY: UnsafeMutablePointer<Float>?, outWidth: UnsafeMutablePointer<Float>?, outHeight: UnsafeMutablePointer<Float>?, outVertexBuffer: ArrayFloat, clipping: SkeletonClipping) {
+        spine_skeleton_get_bounds_2(wrappee, outX, outY, outWidth, outHeight, outVertexBuffer, clipping.wrappee)
+    }
+
+    public func getColor() -> Color {
+        let result = spine_skeleton_get_color(wrappee)
+        return Color(result)
+    }
+
+    public func setColor(color: Color) {
+        spine_skeleton_set_color_1(wrappee, color.wrappee)
+    }
+
+    public func setColor(r: Float, g: Float, b: Float, a: Float) {
+        spine_skeleton_set_color_2(wrappee, r, g, b, a)
+    }
+
+    public func getScaleX() -> Float {
+        return spine_skeleton_get_scale_x(wrappee)
+    }
+
+    public func setScaleX(inValue: Float) {
+        spine_skeleton_set_scale_x(wrappee, inValue)
+    }
+
+    public func getScaleY() -> Float {
+        return spine_skeleton_get_scale_y(wrappee)
+    }
+
+    public func setScaleY(inValue: Float) {
+        spine_skeleton_set_scale_y(wrappee, inValue)
+    }
+
+    public func setScale(scaleX: Float, scaleY: Float) {
+        spine_skeleton_set_scale(wrappee, scaleX, scaleY)
+    }
+
+    public func getX() -> Float {
+        return spine_skeleton_get_x(wrappee)
+    }
+
+    public func setX(inValue: Float) {
+        spine_skeleton_set_x(wrappee, inValue)
+    }
+
+    public func getY() -> Float {
+        return spine_skeleton_get_y(wrappee)
+    }
+
+    public func setY(inValue: Float) {
+        spine_skeleton_set_y(wrappee, inValue)
+    }
+
+    public func setPosition(x: Float, y: Float) {
+        spine_skeleton_set_position(wrappee, x, y)
+    }
+
+    public func getPosition(x: UnsafeMutablePointer<Float>?, y: UnsafeMutablePointer<Float>?) {
+        spine_skeleton_get_position(wrappee, x, y)
+    }
+
+    public func getWindX() -> Float {
+        return spine_skeleton_get_wind_x(wrappee)
+    }
+
+    public func setWindX(windX: Float) {
+        spine_skeleton_set_wind_x(wrappee, windX)
+    }
+
+    public func getWindY() -> Float {
+        return spine_skeleton_get_wind_y(wrappee)
+    }
+
+    public func setWindY(windY: Float) {
+        spine_skeleton_set_wind_y(wrappee, windY)
+    }
+
+    public func getGravityX() -> Float {
+        return spine_skeleton_get_gravity_x(wrappee)
+    }
+
+    public func setGravityX(gravityX: Float) {
+        spine_skeleton_set_gravity_x(wrappee, gravityX)
+    }
+
+    public func getGravityY() -> Float {
+        return spine_skeleton_get_gravity_y(wrappee)
+    }
+
+    public func setGravityY(gravityY: Float) {
+        spine_skeleton_set_gravity_y(wrappee, gravityY)
+    }
+
+    public func physicsTranslate(x: Float, y: Float) {
+        spine_skeleton_physics_translate(wrappee, x, y)
+    }
+
+    public func physicsRotate(x: Float, y: Float, degrees: Float) {
+        spine_skeleton_physics_rotate(wrappee, x, y, degrees)
+    }
+
+    public func getTime() -> Float {
+        return spine_skeleton_get_time(wrappee)
+    }
+
+    public func setTime(time: Float) {
+        spine_skeleton_set_time(wrappee, time)
+    }
+
+    public func update(delta: Float) {
+        spine_skeleton_update(wrappee, delta)
+    }
+
+    deinit {
+        spine_skeleton_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/SkeletonBinary.swift

@@ -0,0 +1,84 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineSkeletonBinary)
+@objcMembers
+public final class SkeletonBinary: NSObject {
+    internal let wrappee: spine_skeleton_binary
+
+    internal init(_ wrappee: spine_skeleton_binary) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? SkeletonBinary else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(atlas: Atlas) {
+        let ptr = spine_skeleton_binary_create(atlas.wrappee)
+        self.init(ptr)
+    }
+
+    public convenience init(attachmentLoader: AttachmentLoader, ownsLoader: Bool) {
+        let ptr = spine_skeleton_binary_create(attachmentLoader.wrappee, ownsLoader)
+        self.init(ptr)
+    }
+
+    public func readSkeletonData(binary: OpaquePointer?, length: Int32) -> SkeletonData {
+        let result = spine_skeleton_binary_read_skeleton_data(wrappee, binary, length)
+        return SkeletonData(result)
+    }
+
+    public func readSkeletonDataFile(path: String?) -> SkeletonData {
+        let result = spine_skeleton_binary_read_skeleton_data_file(wrappee, path?.cString(using: .utf8))
+        return SkeletonData(result)
+    }
+
+    public func setScale(scale: Float) {
+        spine_skeleton_binary_set_scale(wrappee, scale)
+    }
+
+    public func getError() -> String? {
+        let result = spine_skeleton_binary_get_error(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    deinit {
+        spine_skeleton_binary_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/SkeletonBounds.swift

@@ -0,0 +1,136 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineSkeletonBounds)
+@objcMembers
+public final class SkeletonBounds: NSObject {
+    internal let wrappee: spine_skeleton_bounds
+
+    internal init(_ wrappee: spine_skeleton_bounds) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? SkeletonBounds else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init() {
+        let ptr = spine_skeleton_bounds_create()
+        self.init(ptr)
+    }
+
+    public func update(skeleton: Skeleton, updateAabb: Bool) {
+        spine_skeleton_bounds_update(wrappee, skeleton.wrappee, updateAabb ? 1 : 0)
+    }
+
+    public func aabbContainsPoint(x: Float, y: Float) -> Bool {
+        return spine_skeleton_bounds_aabb_contains_point(wrappee, x, y) != 0
+    }
+
+    public func aabbIntersectsSegment(x1: Float, y1: Float, x2: Float, y2: Float) -> Bool {
+        return spine_skeleton_bounds_aabb_intersects_segment(wrappee, x1, y1, x2, y2) != 0
+    }
+
+    public func aabbIntersectsSkeleton(bounds: SkeletonBounds) -> Bool {
+        return spine_skeleton_bounds_aabb_intersects_skeleton(wrappee, bounds.wrappee) != 0
+    }
+
+    public func containsPoint(polygon: Polygon, x: Float, y: Float) -> Bool {
+        return spine_skeleton_bounds_contains_point_1(wrappee, polygon.wrappee, x, y) != 0
+    }
+
+    public func containsPoint(x: Float, y: Float) -> BoundingBoxAttachment {
+        let result = spine_skeleton_bounds_contains_point_2(wrappee, x, y)
+        return BoundingBoxAttachment(result)
+    }
+
+    public func intersectsSegment(x1: Float, y1: Float, x2: Float, y2: Float) -> BoundingBoxAttachment {
+        let result = spine_skeleton_bounds_intersects_segment_1(wrappee, x1, y1, x2, y2)
+        return BoundingBoxAttachment(result)
+    }
+
+    public func intersectsSegment(polygon: Polygon, x1: Float, y1: Float, x2: Float, y2: Float) -> Bool {
+        return spine_skeleton_bounds_intersects_segment_2(wrappee, polygon.wrappee, x1, y1, x2, y2) != 0
+    }
+
+    public func getPolygon(attachment: BoundingBoxAttachment) -> Polygon {
+        let result = spine_skeleton_bounds_get_polygon(wrappee, attachment.wrappee)
+        return Polygon(result)
+    }
+
+    public func getBoundingBox(polygon: Polygon) -> BoundingBoxAttachment {
+        let result = spine_skeleton_bounds_get_bounding_box(wrappee, polygon.wrappee)
+        return BoundingBoxAttachment(result)
+    }
+
+    public func getPolygons() -> ArrayPolygon {
+        return spine_skeleton_bounds_get_polygons(wrappee)
+    }
+
+    public func getBoundingBoxes() -> ArrayBoundingBoxAttachment {
+        return spine_skeleton_bounds_get_bounding_boxes(wrappee)
+    }
+
+    public func getMinX() -> Float {
+        return spine_skeleton_bounds_get_min_x(wrappee)
+    }
+
+    public func getMinY() -> Float {
+        return spine_skeleton_bounds_get_min_y(wrappee)
+    }
+
+    public func getMaxX() -> Float {
+        return spine_skeleton_bounds_get_max_x(wrappee)
+    }
+
+    public func getMaxY() -> Float {
+        return spine_skeleton_bounds_get_max_y(wrappee)
+    }
+
+    public func getWidth() -> Float {
+        return spine_skeleton_bounds_get_width(wrappee)
+    }
+
+    public func getHeight() -> Float {
+        return spine_skeleton_bounds_get_height(wrappee)
+    }
+
+    deinit {
+        spine_skeleton_bounds_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/SkeletonClipping.swift

@@ -0,0 +1,100 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineSkeletonClipping)
+@objcMembers
+public final class SkeletonClipping: NSObject {
+    internal let wrappee: spine_skeleton_clipping
+
+    internal init(_ wrappee: spine_skeleton_clipping) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? SkeletonClipping else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init() {
+        let ptr = spine_skeleton_clipping_create()
+        self.init(ptr)
+    }
+
+    public func clipStart(skeleton: Skeleton, slot: Slot, clip: ClippingAttachment) -> size_t {
+        return spine_skeleton_clipping_clip_start(wrappee, skeleton.wrappee, slot.wrappee, clip.wrappee)
+    }
+
+    public func clipEnd(slot: Slot) {
+        spine_skeleton_clipping_clip_end_1(wrappee, slot.wrappee)
+    }
+
+    public func clipEnd() {
+        spine_skeleton_clipping_clip_end_2(wrappee)
+    }
+
+    public func clipTriangles(vertices: UnsafeMutablePointer<Float>?, triangles: OpaquePointer?, trianglesLength: size_t) -> Bool {
+        return spine_skeleton_clipping_clip_triangles_1(wrappee, vertices, triangles, trianglesLength) != 0
+    }
+
+    public func clipTriangles(vertices: UnsafeMutablePointer<Float>?, triangles: OpaquePointer?, trianglesLength: size_t, uvs: UnsafeMutablePointer<Float>?, stride: size_t) -> Bool {
+        return spine_skeleton_clipping_clip_triangles_2(wrappee, vertices, triangles, trianglesLength, uvs, stride) != 0
+    }
+
+    public func clipTriangles(vertices: ArrayFloat, triangles: ArrayUnsignedShort, uvs: ArrayFloat, stride: size_t) -> Bool {
+        return spine_skeleton_clipping_clip_triangles_3(wrappee, vertices, triangles, uvs, stride) != 0
+    }
+
+    public func isClipping() -> Bool {
+        return spine_skeleton_clipping_is_clipping(wrappee) != 0
+    }
+
+    public func getClippedVertices() -> ArrayFloat {
+        return spine_skeleton_clipping_get_clipped_vertices(wrappee)
+    }
+
+    public func getClippedTriangles() -> ArrayUnsignedShort {
+        return spine_skeleton_clipping_get_clipped_triangles(wrappee)
+    }
+
+    public func getClippedUVs() -> ArrayFloat {
+        return spine_skeleton_clipping_get_clipped_u_vs(wrappee)
+    }
+
+    deinit {
+        spine_skeleton_clipping_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/SkeletonData.swift

@@ -0,0 +1,211 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineSkeletonData)
+@objcMembers
+public final class SkeletonData: NSObject {
+    internal let wrappee: spine_skeleton_data
+
+    internal init(_ wrappee: spine_skeleton_data) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? SkeletonData else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init() {
+        let ptr = spine_skeleton_data_create()
+        self.init(ptr)
+    }
+
+    public func findBone(boneName: String?) -> BoneData {
+        let result = spine_skeleton_data_find_bone(wrappee, boneName?.cString(using: .utf8))
+        return BoneData(result)
+    }
+
+    public func findSlot(slotName: String?) -> SlotData {
+        let result = spine_skeleton_data_find_slot(wrappee, slotName?.cString(using: .utf8))
+        return SlotData(result)
+    }
+
+    public func findSkin(skinName: String?) -> Skin {
+        let result = spine_skeleton_data_find_skin(wrappee, skinName?.cString(using: .utf8))
+        return Skin(result)
+    }
+
+    public func findEvent(eventDataName: String?) -> EventData {
+        let result = spine_skeleton_data_find_event(wrappee, eventDataName?.cString(using: .utf8))
+        return EventData(result)
+    }
+
+    public func findAnimation(animationName: String?) -> Animation {
+        let result = spine_skeleton_data_find_animation(wrappee, animationName?.cString(using: .utf8))
+        return Animation(result)
+    }
+
+    public func getName() -> String? {
+        let result = spine_skeleton_data_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func setName(inValue: String?) {
+        spine_skeleton_data_set_name(wrappee, inValue?.cString(using: .utf8))
+    }
+
+    public func getBones() -> ArrayBoneData {
+        return spine_skeleton_data_get_bones(wrappee)
+    }
+
+    public func getSlots() -> ArraySlotData {
+        return spine_skeleton_data_get_slots(wrappee)
+    }
+
+    public func getSkins() -> ArraySkin {
+        return spine_skeleton_data_get_skins(wrappee)
+    }
+
+    public func getDefaultSkin() -> Skin {
+        let result = spine_skeleton_data_get_default_skin(wrappee)
+        return Skin(result)
+    }
+
+    public func setDefaultSkin(inValue: Skin) {
+        spine_skeleton_data_set_default_skin(wrappee, inValue.wrappee)
+    }
+
+    public func getEvents() -> ArrayEventData {
+        return spine_skeleton_data_get_events(wrappee)
+    }
+
+    public func getAnimations() -> ArrayAnimation {
+        return spine_skeleton_data_get_animations(wrappee)
+    }
+
+    public func getConstraints() -> ArrayConstraintData {
+        return spine_skeleton_data_get_constraints(wrappee)
+    }
+
+    public func getX() -> Float {
+        return spine_skeleton_data_get_x(wrappee)
+    }
+
+    public func setX(inValue: Float) {
+        spine_skeleton_data_set_x(wrappee, inValue)
+    }
+
+    public func getY() -> Float {
+        return spine_skeleton_data_get_y(wrappee)
+    }
+
+    public func setY(inValue: Float) {
+        spine_skeleton_data_set_y(wrappee, inValue)
+    }
+
+    public func getWidth() -> Float {
+        return spine_skeleton_data_get_width(wrappee)
+    }
+
+    public func setWidth(inValue: Float) {
+        spine_skeleton_data_set_width(wrappee, inValue)
+    }
+
+    public func getHeight() -> Float {
+        return spine_skeleton_data_get_height(wrappee)
+    }
+
+    public func setHeight(inValue: Float) {
+        spine_skeleton_data_set_height(wrappee, inValue)
+    }
+
+    public func getReferenceScale() -> Float {
+        return spine_skeleton_data_get_reference_scale(wrappee)
+    }
+
+    public func setReferenceScale(inValue: Float) {
+        spine_skeleton_data_set_reference_scale(wrappee, inValue)
+    }
+
+    public func getVersion() -> String? {
+        let result = spine_skeleton_data_get_version(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func setVersion(inValue: String?) {
+        spine_skeleton_data_set_version(wrappee, inValue?.cString(using: .utf8))
+    }
+
+    public func getHash() -> String? {
+        let result = spine_skeleton_data_get_hash(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func setHash(inValue: String?) {
+        spine_skeleton_data_set_hash(wrappee, inValue?.cString(using: .utf8))
+    }
+
+    public func getImagesPath() -> String? {
+        let result = spine_skeleton_data_get_images_path(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func setImagesPath(inValue: String?) {
+        spine_skeleton_data_set_images_path(wrappee, inValue?.cString(using: .utf8))
+    }
+
+    public func getAudioPath() -> String? {
+        let result = spine_skeleton_data_get_audio_path(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func setAudioPath(inValue: String?) {
+        spine_skeleton_data_set_audio_path(wrappee, inValue?.cString(using: .utf8))
+    }
+
+    public func getFps() -> Float {
+        return spine_skeleton_data_get_fps(wrappee)
+    }
+
+    public func setFps(inValue: Float) {
+        spine_skeleton_data_set_fps(wrappee, inValue)
+    }
+
+    deinit {
+        spine_skeleton_data_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/SkeletonJson.swift

@@ -0,0 +1,84 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineSkeletonJson)
+@objcMembers
+public final class SkeletonJson: NSObject {
+    internal let wrappee: spine_skeleton_json
+
+    internal init(_ wrappee: spine_skeleton_json) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? SkeletonJson else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(atlas: Atlas) {
+        let ptr = spine_skeleton_json_create(atlas.wrappee)
+        self.init(ptr)
+    }
+
+    public convenience init(attachmentLoader: AttachmentLoader, ownsLoader: Bool) {
+        let ptr = spine_skeleton_json_create(attachmentLoader.wrappee, ownsLoader)
+        self.init(ptr)
+    }
+
+    public func readSkeletonDataFile(path: String?) -> SkeletonData {
+        let result = spine_skeleton_json_read_skeleton_data_file(wrappee, path?.cString(using: .utf8))
+        return SkeletonData(result)
+    }
+
+    public func readSkeletonData(json: String?) -> SkeletonData {
+        let result = spine_skeleton_json_read_skeleton_data(wrappee, json?.cString(using: .utf8))
+        return SkeletonData(result)
+    }
+
+    public func setScale(scale: Float) {
+        spine_skeleton_json_set_scale(wrappee, scale)
+    }
+
+    public func getError() -> String? {
+        let result = spine_skeleton_json_get_error(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    deinit {
+        spine_skeleton_json_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/SkeletonRenderer.swift

@@ -0,0 +1,65 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineSkeletonRenderer)
+@objcMembers
+public final class SkeletonRenderer: NSObject {
+    internal let wrappee: spine_skeleton_renderer
+
+    internal init(_ wrappee: spine_skeleton_renderer) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? SkeletonRenderer else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init() {
+        let ptr = spine_skeleton_renderer_create()
+        self.init(ptr)
+    }
+
+    public func render(skeleton: Skeleton) -> RenderCommand {
+        let result = spine_skeleton_renderer_render(wrappee, skeleton.wrappee)
+        return RenderCommand(result)
+    }
+
+    deinit {
+        spine_skeleton_renderer_dispose(wrappee)
+    }
+}

spine-ios/Sources/Spine/Generated/Skin.swift

@@ -0,0 +1,103 @@
+// Spine Runtimes License Agreement
+// Last updated April 5, 2025. Replaces all prior versions.
+// 
+// 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,
+// "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.
+// 
+
+import Foundation
+
+@objc(SpineSkin)
+@objcMembers
+public final class Skin: NSObject {
+    internal let wrappee: spine_skin
+
+    internal init(_ wrappee: spine_skin) {
+        self.wrappee = wrappee
+        super.init()
+    }
+
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? Skin else { return false }
+        return self.wrappee == other.wrappee
+    }
+
+    public override var hash: Int {
+        var hasher = Hasher()
+        hasher.combine(self.wrappee)
+        return hasher.finalize()
+    }
+
+    public convenience init(name: String?) {
+        let ptr = spine_skin_create(name)
+        self.init(ptr)
+    }
+
+    public func setAttachment(slotIndex: size_t, name: String?, attachment: Attachment) {
+        spine_skin_set_attachment(wrappee, slotIndex, name?.cString(using: .utf8), attachment.wrappee)
+    }
+
+    public func getAttachment(slotIndex: size_t, name: String?) -> Attachment {
+        let result = spine_skin_get_attachment(wrappee, slotIndex, name?.cString(using: .utf8))
+        return Attachment(result)
+    }
+
+    public func removeAttachment(slotIndex: size_t, name: String?) {
+        spine_skin_remove_attachment(wrappee, slotIndex, name?.cString(using: .utf8))
+    }
+
+    public func findAttachmentsForSlot(slotIndex: size_t, attachments: ArrayAttachment) {
+        spine_skin_find_attachments_for_slot(wrappee, slotIndex, attachments)
+    }
+
+    public func getName() -> String? {
+        let result = spine_skin_get_name(wrappee)
+        return result != nil ? String(cString: result!) : nil
+    }
+
+    public func addSkin(other: Skin) {
+        spine_skin_add_skin(wrappee, other.wrappee)
+    }
+
+    public func copySkin(other: Skin) {
+        spine_skin_copy_skin(wrappee, other.wrappee)
+    }
+
+    public func getBones() -> ArrayBoneData {
+        return spine_skin_get_bones(wrappee)
+    }
+
+    public func getConstraints() -> ArrayConstraintData {
+        return spine_skin_get_constraints(wrappee)
+    }
+
+    public func getColor() -> Color {
+        let result = spine_skin_get_color(wrappee)
+        return Color(result)
+    }
+
+    deinit {
+        spine_skin_dispose(wrappee)
+    }
+}