spine-runtimes/spine-flutter/lib/generated/spine_dart_bindings_generated.dart

// ignore_for_file: always_specify_types, constant_identifier_names
// ignore_for_file: camel_case_types
// ignore_for_file: non_constant_identifier_names

// AUTO GENERATED FILE, DO NOT EDIT.
//
// Generated by `package:ffigen`.
// ignore_for_file: type=lint
import 'package:universal_ffi/ffi.dart' as ffi;

/// Bindings for Spine C headers.
///
/// Regenerate bindings with `dart run ffigen --config ffigen.yaml`.
///
class SpineDartBindings {
  /// Holds the symbol lookup function.
  final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName) _lookup;

  /// The symbols are looked up in [dynamicLibrary].
  SpineDartBindings(ffi.DynamicLibrary dynamicLibrary) : _lookup = dynamicLibrary.lookup;

  /// The symbols are looked up with [lookup].
  SpineDartBindings.fromLookup(ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName) lookup)
      : _lookup = lookup;

  spine_array_float spine_array_float_create() {
    return _spine_array_float_create();
  }

  late final _spine_array_float_createPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function()>>('spine_array_float_create');
  late final _spine_array_float_create = _spine_array_float_createPtr.asFunction<spine_array_float Function()>();

  spine_array_float spine_array_float_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_float_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_float_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(ffi.Size)>>('spine_array_float_create_with_capacity');
  late final _spine_array_float_create_with_capacity =
      _spine_array_float_create_with_capacityPtr.asFunction<spine_array_float Function(int)>();

  void spine_array_float_dispose(
    spine_array_float array,
  ) {
    return _spine_array_float_dispose(
      array,
    );
  }

  late final _spine_array_float_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_float)>>('spine_array_float_dispose');
  late final _spine_array_float_dispose = _spine_array_float_disposePtr.asFunction<void Function(spine_array_float)>();

  void spine_array_float_clear(
    spine_array_float array,
  ) {
    return _spine_array_float_clear(
      array,
    );
  }

  late final _spine_array_float_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_float)>>('spine_array_float_clear');
  late final _spine_array_float_clear = _spine_array_float_clearPtr.asFunction<void Function(spine_array_float)>();

  int spine_array_float_get_capacity(
    spine_array_float array,
  ) {
    return _spine_array_float_get_capacity(
      array,
    );
  }

  late final _spine_array_float_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_float)>>('spine_array_float_get_capacity');
  late final _spine_array_float_get_capacity =
      _spine_array_float_get_capacityPtr.asFunction<int Function(spine_array_float)>();

  int spine_array_float_size(
    spine_array_float array,
  ) {
    return _spine_array_float_size(
      array,
    );
  }

  late final _spine_array_float_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_float)>>('spine_array_float_size');
  late final _spine_array_float_size = _spine_array_float_sizePtr.asFunction<int Function(spine_array_float)>();

  spine_array_float spine_array_float_set_size(
    spine_array_float array,
    int newSize,
    double defaultValue,
  ) {
    return _spine_array_float_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_float_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_array_float, ffi.Size, ffi.Float)>>(
          'spine_array_float_set_size');
  late final _spine_array_float_set_size =
      _spine_array_float_set_sizePtr.asFunction<spine_array_float Function(spine_array_float, int, double)>();

  void spine_array_float_ensure_capacity(
    spine_array_float array,
    int newCapacity,
  ) {
    return _spine_array_float_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_float_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_float, ffi.Size)>>('spine_array_float_ensure_capacity');
  late final _spine_array_float_ensure_capacity =
      _spine_array_float_ensure_capacityPtr.asFunction<void Function(spine_array_float, int)>();

  void spine_array_float_add(
    spine_array_float array,
    double inValue,
  ) {
    return _spine_array_float_add(
      array,
      inValue,
    );
  }

  late final _spine_array_float_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_float, ffi.Float)>>('spine_array_float_add');
  late final _spine_array_float_add = _spine_array_float_addPtr.asFunction<void Function(spine_array_float, double)>();

  void spine_array_float_add_all(
    spine_array_float array,
    spine_array_float inValue,
  ) {
    return _spine_array_float_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_float_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_float, spine_array_float)>>('spine_array_float_add_all');
  late final _spine_array_float_add_all =
      _spine_array_float_add_allPtr.asFunction<void Function(spine_array_float, spine_array_float)>();

  void spine_array_float_clear_and_add_all(
    spine_array_float array,
    spine_array_float inValue,
  ) {
    return _spine_array_float_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_float_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_float, spine_array_float)>>(
          'spine_array_float_clear_and_add_all');
  late final _spine_array_float_clear_and_add_all =
      _spine_array_float_clear_and_add_allPtr.asFunction<void Function(spine_array_float, spine_array_float)>();

  void spine_array_float_remove_at(
    spine_array_float array,
    int inIndex,
  ) {
    return _spine_array_float_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_float_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_float, ffi.Size)>>('spine_array_float_remove_at');
  late final _spine_array_float_remove_at =
      _spine_array_float_remove_atPtr.asFunction<void Function(spine_array_float, int)>();

  bool spine_array_float_contains(
    spine_array_float array,
    double inValue,
  ) {
    return _spine_array_float_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_float_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_float, ffi.Float)>>('spine_array_float_contains');
  late final _spine_array_float_contains =
      _spine_array_float_containsPtr.asFunction<bool Function(spine_array_float, double)>();

  int spine_array_float_index_of(
    spine_array_float array,
    double inValue,
  ) {
    return _spine_array_float_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_float_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_float, ffi.Float)>>('spine_array_float_index_of');
  late final _spine_array_float_index_of =
      _spine_array_float_index_ofPtr.asFunction<int Function(spine_array_float, double)>();

  ffi.Pointer<ffi.Float> spine_array_float_buffer(
    spine_array_float array,
  ) {
    return _spine_array_float_buffer(
      array,
    );
  }

  late final _spine_array_float_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_array_float)>>('spine_array_float_buffer');
  late final _spine_array_float_buffer =
      _spine_array_float_bufferPtr.asFunction<ffi.Pointer<ffi.Float> Function(spine_array_float)>();

  spine_array_int spine_array_int_create() {
    return _spine_array_int_create();
  }

  late final _spine_array_int_createPtr =
      _lookup<ffi.NativeFunction<spine_array_int Function()>>('spine_array_int_create');
  late final _spine_array_int_create = _spine_array_int_createPtr.asFunction<spine_array_int Function()>();

  spine_array_int spine_array_int_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_int_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_int_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_int Function(ffi.Size)>>('spine_array_int_create_with_capacity');
  late final _spine_array_int_create_with_capacity =
      _spine_array_int_create_with_capacityPtr.asFunction<spine_array_int Function(int)>();

  void spine_array_int_dispose(
    spine_array_int array,
  ) {
    return _spine_array_int_dispose(
      array,
    );
  }

  late final _spine_array_int_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_int)>>('spine_array_int_dispose');
  late final _spine_array_int_dispose = _spine_array_int_disposePtr.asFunction<void Function(spine_array_int)>();

  void spine_array_int_clear(
    spine_array_int array,
  ) {
    return _spine_array_int_clear(
      array,
    );
  }

  late final _spine_array_int_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_int)>>('spine_array_int_clear');
  late final _spine_array_int_clear = _spine_array_int_clearPtr.asFunction<void Function(spine_array_int)>();

  int spine_array_int_get_capacity(
    spine_array_int array,
  ) {
    return _spine_array_int_get_capacity(
      array,
    );
  }

  late final _spine_array_int_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_int)>>('spine_array_int_get_capacity');
  late final _spine_array_int_get_capacity =
      _spine_array_int_get_capacityPtr.asFunction<int Function(spine_array_int)>();

  int spine_array_int_size(
    spine_array_int array,
  ) {
    return _spine_array_int_size(
      array,
    );
  }

  late final _spine_array_int_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_int)>>('spine_array_int_size');
  late final _spine_array_int_size = _spine_array_int_sizePtr.asFunction<int Function(spine_array_int)>();

  spine_array_int spine_array_int_set_size(
    spine_array_int array,
    int newSize,
    int defaultValue,
  ) {
    return _spine_array_int_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_int_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_int Function(spine_array_int, ffi.Size, ffi.Int)>>(
          'spine_array_int_set_size');
  late final _spine_array_int_set_size =
      _spine_array_int_set_sizePtr.asFunction<spine_array_int Function(spine_array_int, int, int)>();

  void spine_array_int_ensure_capacity(
    spine_array_int array,
    int newCapacity,
  ) {
    return _spine_array_int_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_int_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_int, ffi.Size)>>('spine_array_int_ensure_capacity');
  late final _spine_array_int_ensure_capacity =
      _spine_array_int_ensure_capacityPtr.asFunction<void Function(spine_array_int, int)>();

  void spine_array_int_add(
    spine_array_int array,
    int inValue,
  ) {
    return _spine_array_int_add(
      array,
      inValue,
    );
  }

  late final _spine_array_int_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_int, ffi.Int)>>('spine_array_int_add');
  late final _spine_array_int_add = _spine_array_int_addPtr.asFunction<void Function(spine_array_int, int)>();

  void spine_array_int_add_all(
    spine_array_int array,
    spine_array_int inValue,
  ) {
    return _spine_array_int_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_int_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_int, spine_array_int)>>('spine_array_int_add_all');
  late final _spine_array_int_add_all =
      _spine_array_int_add_allPtr.asFunction<void Function(spine_array_int, spine_array_int)>();

  void spine_array_int_clear_and_add_all(
    spine_array_int array,
    spine_array_int inValue,
  ) {
    return _spine_array_int_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_int_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_int, spine_array_int)>>(
          'spine_array_int_clear_and_add_all');
  late final _spine_array_int_clear_and_add_all =
      _spine_array_int_clear_and_add_allPtr.asFunction<void Function(spine_array_int, spine_array_int)>();

  void spine_array_int_remove_at(
    spine_array_int array,
    int inIndex,
  ) {
    return _spine_array_int_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_int_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_int, ffi.Size)>>('spine_array_int_remove_at');
  late final _spine_array_int_remove_at =
      _spine_array_int_remove_atPtr.asFunction<void Function(spine_array_int, int)>();

  bool spine_array_int_contains(
    spine_array_int array,
    int inValue,
  ) {
    return _spine_array_int_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_int_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_int, ffi.Int)>>('spine_array_int_contains');
  late final _spine_array_int_contains = _spine_array_int_containsPtr.asFunction<bool Function(spine_array_int, int)>();

  int spine_array_int_index_of(
    spine_array_int array,
    int inValue,
  ) {
    return _spine_array_int_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_int_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_int, ffi.Int)>>('spine_array_int_index_of');
  late final _spine_array_int_index_of = _spine_array_int_index_ofPtr.asFunction<int Function(spine_array_int, int)>();

  ffi.Pointer<ffi.Int> spine_array_int_buffer(
    spine_array_int array,
  ) {
    return _spine_array_int_buffer(
      array,
    );
  }

  late final _spine_array_int_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Int> Function(spine_array_int)>>('spine_array_int_buffer');
  late final _spine_array_int_buffer =
      _spine_array_int_bufferPtr.asFunction<ffi.Pointer<ffi.Int> Function(spine_array_int)>();

  spine_array_unsigned_short spine_array_unsigned_short_create() {
    return _spine_array_unsigned_short_create();
  }

  late final _spine_array_unsigned_short_createPtr =
      _lookup<ffi.NativeFunction<spine_array_unsigned_short Function()>>('spine_array_unsigned_short_create');
  late final _spine_array_unsigned_short_create =
      _spine_array_unsigned_short_createPtr.asFunction<spine_array_unsigned_short Function()>();

  spine_array_unsigned_short spine_array_unsigned_short_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_unsigned_short_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_unsigned_short_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_unsigned_short Function(ffi.Size)>>(
          'spine_array_unsigned_short_create_with_capacity');
  late final _spine_array_unsigned_short_create_with_capacity =
      _spine_array_unsigned_short_create_with_capacityPtr.asFunction<spine_array_unsigned_short Function(int)>();

  void spine_array_unsigned_short_dispose(
    spine_array_unsigned_short array,
  ) {
    return _spine_array_unsigned_short_dispose(
      array,
    );
  }

  late final _spine_array_unsigned_short_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_unsigned_short)>>('spine_array_unsigned_short_dispose');
  late final _spine_array_unsigned_short_dispose =
      _spine_array_unsigned_short_disposePtr.asFunction<void Function(spine_array_unsigned_short)>();

  void spine_array_unsigned_short_clear(
    spine_array_unsigned_short array,
  ) {
    return _spine_array_unsigned_short_clear(
      array,
    );
  }

  late final _spine_array_unsigned_short_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_unsigned_short)>>('spine_array_unsigned_short_clear');
  late final _spine_array_unsigned_short_clear =
      _spine_array_unsigned_short_clearPtr.asFunction<void Function(spine_array_unsigned_short)>();

  int spine_array_unsigned_short_get_capacity(
    spine_array_unsigned_short array,
  ) {
    return _spine_array_unsigned_short_get_capacity(
      array,
    );
  }

  late final _spine_array_unsigned_short_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_unsigned_short)>>(
          'spine_array_unsigned_short_get_capacity');
  late final _spine_array_unsigned_short_get_capacity =
      _spine_array_unsigned_short_get_capacityPtr.asFunction<int Function(spine_array_unsigned_short)>();

  int spine_array_unsigned_short_size(
    spine_array_unsigned_short array,
  ) {
    return _spine_array_unsigned_short_size(
      array,
    );
  }

  late final _spine_array_unsigned_short_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_unsigned_short)>>('spine_array_unsigned_short_size');
  late final _spine_array_unsigned_short_size =
      _spine_array_unsigned_short_sizePtr.asFunction<int Function(spine_array_unsigned_short)>();

  spine_array_unsigned_short spine_array_unsigned_short_set_size(
    spine_array_unsigned_short array,
    int newSize,
    int defaultValue,
  ) {
    return _spine_array_unsigned_short_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_unsigned_short_set_sizePtr = _lookup<
      ffi.NativeFunction<
          spine_array_unsigned_short Function(
              spine_array_unsigned_short, ffi.Size, ffi.UnsignedShort)>>('spine_array_unsigned_short_set_size');
  late final _spine_array_unsigned_short_set_size = _spine_array_unsigned_short_set_sizePtr
      .asFunction<spine_array_unsigned_short Function(spine_array_unsigned_short, int, int)>();

  void spine_array_unsigned_short_ensure_capacity(
    spine_array_unsigned_short array,
    int newCapacity,
  ) {
    return _spine_array_unsigned_short_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_unsigned_short_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_unsigned_short, ffi.Size)>>(
          'spine_array_unsigned_short_ensure_capacity');
  late final _spine_array_unsigned_short_ensure_capacity =
      _spine_array_unsigned_short_ensure_capacityPtr.asFunction<void Function(spine_array_unsigned_short, int)>();

  void spine_array_unsigned_short_add(
    spine_array_unsigned_short array,
    int inValue,
  ) {
    return _spine_array_unsigned_short_add(
      array,
      inValue,
    );
  }

  late final _spine_array_unsigned_short_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_unsigned_short, ffi.UnsignedShort)>>(
          'spine_array_unsigned_short_add');
  late final _spine_array_unsigned_short_add =
      _spine_array_unsigned_short_addPtr.asFunction<void Function(spine_array_unsigned_short, int)>();

  void spine_array_unsigned_short_add_all(
    spine_array_unsigned_short array,
    spine_array_unsigned_short inValue,
  ) {
    return _spine_array_unsigned_short_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_unsigned_short_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_unsigned_short, spine_array_unsigned_short)>>(
          'spine_array_unsigned_short_add_all');
  late final _spine_array_unsigned_short_add_all = _spine_array_unsigned_short_add_allPtr
      .asFunction<void Function(spine_array_unsigned_short, spine_array_unsigned_short)>();

  void spine_array_unsigned_short_clear_and_add_all(
    spine_array_unsigned_short array,
    spine_array_unsigned_short inValue,
  ) {
    return _spine_array_unsigned_short_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_unsigned_short_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_unsigned_short, spine_array_unsigned_short)>>(
          'spine_array_unsigned_short_clear_and_add_all');
  late final _spine_array_unsigned_short_clear_and_add_all = _spine_array_unsigned_short_clear_and_add_allPtr
      .asFunction<void Function(spine_array_unsigned_short, spine_array_unsigned_short)>();

  void spine_array_unsigned_short_remove_at(
    spine_array_unsigned_short array,
    int inIndex,
  ) {
    return _spine_array_unsigned_short_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_unsigned_short_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_unsigned_short, ffi.Size)>>(
          'spine_array_unsigned_short_remove_at');
  late final _spine_array_unsigned_short_remove_at =
      _spine_array_unsigned_short_remove_atPtr.asFunction<void Function(spine_array_unsigned_short, int)>();

  bool spine_array_unsigned_short_contains(
    spine_array_unsigned_short array,
    int inValue,
  ) {
    return _spine_array_unsigned_short_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_unsigned_short_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_unsigned_short, ffi.UnsignedShort)>>(
          'spine_array_unsigned_short_contains');
  late final _spine_array_unsigned_short_contains =
      _spine_array_unsigned_short_containsPtr.asFunction<bool Function(spine_array_unsigned_short, int)>();

  int spine_array_unsigned_short_index_of(
    spine_array_unsigned_short array,
    int inValue,
  ) {
    return _spine_array_unsigned_short_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_unsigned_short_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_unsigned_short, ffi.UnsignedShort)>>(
          'spine_array_unsigned_short_index_of');
  late final _spine_array_unsigned_short_index_of =
      _spine_array_unsigned_short_index_ofPtr.asFunction<int Function(spine_array_unsigned_short, int)>();

  ffi.Pointer<ffi.UnsignedShort> spine_array_unsigned_short_buffer(
    spine_array_unsigned_short array,
  ) {
    return _spine_array_unsigned_short_buffer(
      array,
    );
  }

  late final _spine_array_unsigned_short_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.UnsignedShort> Function(spine_array_unsigned_short)>>(
          'spine_array_unsigned_short_buffer');
  late final _spine_array_unsigned_short_buffer = _spine_array_unsigned_short_bufferPtr
      .asFunction<ffi.Pointer<ffi.UnsignedShort> Function(spine_array_unsigned_short)>();

  spine_array_property_id spine_array_property_id_create() {
    return _spine_array_property_id_create();
  }

  late final _spine_array_property_id_createPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function()>>('spine_array_property_id_create');
  late final _spine_array_property_id_create =
      _spine_array_property_id_createPtr.asFunction<spine_array_property_id Function()>();

  spine_array_property_id spine_array_property_id_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_property_id_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_property_id_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(ffi.Size)>>(
          'spine_array_property_id_create_with_capacity');
  late final _spine_array_property_id_create_with_capacity =
      _spine_array_property_id_create_with_capacityPtr.asFunction<spine_array_property_id Function(int)>();

  void spine_array_property_id_dispose(
    spine_array_property_id array,
  ) {
    return _spine_array_property_id_dispose(
      array,
    );
  }

  late final _spine_array_property_id_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_property_id)>>('spine_array_property_id_dispose');
  late final _spine_array_property_id_dispose =
      _spine_array_property_id_disposePtr.asFunction<void Function(spine_array_property_id)>();

  void spine_array_property_id_clear(
    spine_array_property_id array,
  ) {
    return _spine_array_property_id_clear(
      array,
    );
  }

  late final _spine_array_property_id_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_property_id)>>('spine_array_property_id_clear');
  late final _spine_array_property_id_clear =
      _spine_array_property_id_clearPtr.asFunction<void Function(spine_array_property_id)>();

  int spine_array_property_id_get_capacity(
    spine_array_property_id array,
  ) {
    return _spine_array_property_id_get_capacity(
      array,
    );
  }

  late final _spine_array_property_id_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_property_id)>>('spine_array_property_id_get_capacity');
  late final _spine_array_property_id_get_capacity =
      _spine_array_property_id_get_capacityPtr.asFunction<int Function(spine_array_property_id)>();

  int spine_array_property_id_size(
    spine_array_property_id array,
  ) {
    return _spine_array_property_id_size(
      array,
    );
  }

  late final _spine_array_property_id_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_property_id)>>('spine_array_property_id_size');
  late final _spine_array_property_id_size =
      _spine_array_property_id_sizePtr.asFunction<int Function(spine_array_property_id)>();

  spine_array_property_id spine_array_property_id_set_size(
    spine_array_property_id array,
    int newSize,
    int defaultValue,
  ) {
    return _spine_array_property_id_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_property_id_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_array_property_id, ffi.Size, ffi.Int64)>>(
          'spine_array_property_id_set_size');
  late final _spine_array_property_id_set_size = _spine_array_property_id_set_sizePtr
      .asFunction<spine_array_property_id Function(spine_array_property_id, int, int)>();

  void spine_array_property_id_ensure_capacity(
    spine_array_property_id array,
    int newCapacity,
  ) {
    return _spine_array_property_id_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_property_id_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_property_id, ffi.Size)>>(
          'spine_array_property_id_ensure_capacity');
  late final _spine_array_property_id_ensure_capacity =
      _spine_array_property_id_ensure_capacityPtr.asFunction<void Function(spine_array_property_id, int)>();

  void spine_array_property_id_add(
    spine_array_property_id array,
    int inValue,
  ) {
    return _spine_array_property_id_add(
      array,
      inValue,
    );
  }

  late final _spine_array_property_id_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_property_id, ffi.Int64)>>('spine_array_property_id_add');
  late final _spine_array_property_id_add =
      _spine_array_property_id_addPtr.asFunction<void Function(spine_array_property_id, int)>();

  void spine_array_property_id_add_all(
    spine_array_property_id array,
    spine_array_property_id inValue,
  ) {
    return _spine_array_property_id_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_property_id_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_property_id, spine_array_property_id)>>(
          'spine_array_property_id_add_all');
  late final _spine_array_property_id_add_all =
      _spine_array_property_id_add_allPtr.asFunction<void Function(spine_array_property_id, spine_array_property_id)>();

  void spine_array_property_id_clear_and_add_all(
    spine_array_property_id array,
    spine_array_property_id inValue,
  ) {
    return _spine_array_property_id_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_property_id_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_property_id, spine_array_property_id)>>(
          'spine_array_property_id_clear_and_add_all');
  late final _spine_array_property_id_clear_and_add_all = _spine_array_property_id_clear_and_add_allPtr
      .asFunction<void Function(spine_array_property_id, spine_array_property_id)>();

  void spine_array_property_id_remove_at(
    spine_array_property_id array,
    int inIndex,
  ) {
    return _spine_array_property_id_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_property_id_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_property_id, ffi.Size)>>(
          'spine_array_property_id_remove_at');
  late final _spine_array_property_id_remove_at =
      _spine_array_property_id_remove_atPtr.asFunction<void Function(spine_array_property_id, int)>();

  bool spine_array_property_id_contains(
    spine_array_property_id array,
    int inValue,
  ) {
    return _spine_array_property_id_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_property_id_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_property_id, ffi.Int64)>>(
          'spine_array_property_id_contains');
  late final _spine_array_property_id_contains =
      _spine_array_property_id_containsPtr.asFunction<bool Function(spine_array_property_id, int)>();

  int spine_array_property_id_index_of(
    spine_array_property_id array,
    int inValue,
  ) {
    return _spine_array_property_id_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_property_id_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_property_id, ffi.Int64)>>(
          'spine_array_property_id_index_of');
  late final _spine_array_property_id_index_of =
      _spine_array_property_id_index_ofPtr.asFunction<int Function(spine_array_property_id, int)>();

  ffi.Pointer<ffi.Int64> spine_array_property_id_buffer(
    spine_array_property_id array,
  ) {
    return _spine_array_property_id_buffer(
      array,
    );
  }

  late final _spine_array_property_id_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Int64> Function(spine_array_property_id)>>(
          'spine_array_property_id_buffer');
  late final _spine_array_property_id_buffer =
      _spine_array_property_id_bufferPtr.asFunction<ffi.Pointer<ffi.Int64> Function(spine_array_property_id)>();

  spine_array_animation spine_array_animation_create() {
    return _spine_array_animation_create();
  }

  late final _spine_array_animation_createPtr =
      _lookup<ffi.NativeFunction<spine_array_animation Function()>>('spine_array_animation_create');
  late final _spine_array_animation_create =
      _spine_array_animation_createPtr.asFunction<spine_array_animation Function()>();

  spine_array_animation spine_array_animation_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_animation_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_animation_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_animation Function(ffi.Size)>>(
          'spine_array_animation_create_with_capacity');
  late final _spine_array_animation_create_with_capacity =
      _spine_array_animation_create_with_capacityPtr.asFunction<spine_array_animation Function(int)>();

  void spine_array_animation_dispose(
    spine_array_animation array,
  ) {
    return _spine_array_animation_dispose(
      array,
    );
  }

  late final _spine_array_animation_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_animation)>>('spine_array_animation_dispose');
  late final _spine_array_animation_dispose =
      _spine_array_animation_disposePtr.asFunction<void Function(spine_array_animation)>();

  void spine_array_animation_clear(
    spine_array_animation array,
  ) {
    return _spine_array_animation_clear(
      array,
    );
  }

  late final _spine_array_animation_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_animation)>>('spine_array_animation_clear');
  late final _spine_array_animation_clear =
      _spine_array_animation_clearPtr.asFunction<void Function(spine_array_animation)>();

  int spine_array_animation_get_capacity(
    spine_array_animation array,
  ) {
    return _spine_array_animation_get_capacity(
      array,
    );
  }

  late final _spine_array_animation_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_animation)>>('spine_array_animation_get_capacity');
  late final _spine_array_animation_get_capacity =
      _spine_array_animation_get_capacityPtr.asFunction<int Function(spine_array_animation)>();

  int spine_array_animation_size(
    spine_array_animation array,
  ) {
    return _spine_array_animation_size(
      array,
    );
  }

  late final _spine_array_animation_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_animation)>>('spine_array_animation_size');
  late final _spine_array_animation_size =
      _spine_array_animation_sizePtr.asFunction<int Function(spine_array_animation)>();

  spine_array_animation spine_array_animation_set_size(
    spine_array_animation array,
    int newSize,
    spine_animation defaultValue,
  ) {
    return _spine_array_animation_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_animation_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_animation Function(spine_array_animation, ffi.Size, spine_animation)>>(
          'spine_array_animation_set_size');
  late final _spine_array_animation_set_size = _spine_array_animation_set_sizePtr
      .asFunction<spine_array_animation Function(spine_array_animation, int, spine_animation)>();

  void spine_array_animation_ensure_capacity(
    spine_array_animation array,
    int newCapacity,
  ) {
    return _spine_array_animation_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_animation_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_animation, ffi.Size)>>(
          'spine_array_animation_ensure_capacity');
  late final _spine_array_animation_ensure_capacity =
      _spine_array_animation_ensure_capacityPtr.asFunction<void Function(spine_array_animation, int)>();

  void spine_array_animation_add(
    spine_array_animation array,
    spine_animation inValue,
  ) {
    return _spine_array_animation_add(
      array,
      inValue,
    );
  }

  late final _spine_array_animation_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_animation, spine_animation)>>(
          'spine_array_animation_add');
  late final _spine_array_animation_add =
      _spine_array_animation_addPtr.asFunction<void Function(spine_array_animation, spine_animation)>();

  void spine_array_animation_add_all(
    spine_array_animation array,
    spine_array_animation inValue,
  ) {
    return _spine_array_animation_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_animation_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_animation, spine_array_animation)>>(
          'spine_array_animation_add_all');
  late final _spine_array_animation_add_all =
      _spine_array_animation_add_allPtr.asFunction<void Function(spine_array_animation, spine_array_animation)>();

  void spine_array_animation_clear_and_add_all(
    spine_array_animation array,
    spine_array_animation inValue,
  ) {
    return _spine_array_animation_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_animation_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_animation, spine_array_animation)>>(
          'spine_array_animation_clear_and_add_all');
  late final _spine_array_animation_clear_and_add_all = _spine_array_animation_clear_and_add_allPtr
      .asFunction<void Function(spine_array_animation, spine_array_animation)>();

  void spine_array_animation_remove_at(
    spine_array_animation array,
    int inIndex,
  ) {
    return _spine_array_animation_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_animation_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_animation, ffi.Size)>>(
          'spine_array_animation_remove_at');
  late final _spine_array_animation_remove_at =
      _spine_array_animation_remove_atPtr.asFunction<void Function(spine_array_animation, int)>();

  bool spine_array_animation_contains(
    spine_array_animation array,
    spine_animation inValue,
  ) {
    return _spine_array_animation_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_animation_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_animation, spine_animation)>>(
          'spine_array_animation_contains');
  late final _spine_array_animation_contains =
      _spine_array_animation_containsPtr.asFunction<bool Function(spine_array_animation, spine_animation)>();

  int spine_array_animation_index_of(
    spine_array_animation array,
    spine_animation inValue,
  ) {
    return _spine_array_animation_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_animation_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_animation, spine_animation)>>(
          'spine_array_animation_index_of');
  late final _spine_array_animation_index_of =
      _spine_array_animation_index_ofPtr.asFunction<int Function(spine_array_animation, spine_animation)>();

  ffi.Pointer<spine_animation> spine_array_animation_buffer(
    spine_array_animation array,
  ) {
    return _spine_array_animation_buffer(
      array,
    );
  }

  late final _spine_array_animation_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_animation> Function(spine_array_animation)>>(
          'spine_array_animation_buffer');
  late final _spine_array_animation_buffer =
      _spine_array_animation_bufferPtr.asFunction<ffi.Pointer<spine_animation> Function(spine_array_animation)>();

  spine_array_atlas_page spine_array_atlas_page_create() {
    return _spine_array_atlas_page_create();
  }

  late final _spine_array_atlas_page_createPtr =
      _lookup<ffi.NativeFunction<spine_array_atlas_page Function()>>('spine_array_atlas_page_create');
  late final _spine_array_atlas_page_create =
      _spine_array_atlas_page_createPtr.asFunction<spine_array_atlas_page Function()>();

  spine_array_atlas_page spine_array_atlas_page_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_atlas_page_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_atlas_page_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_atlas_page Function(ffi.Size)>>(
          'spine_array_atlas_page_create_with_capacity');
  late final _spine_array_atlas_page_create_with_capacity =
      _spine_array_atlas_page_create_with_capacityPtr.asFunction<spine_array_atlas_page Function(int)>();

  void spine_array_atlas_page_dispose(
    spine_array_atlas_page array,
  ) {
    return _spine_array_atlas_page_dispose(
      array,
    );
  }

  late final _spine_array_atlas_page_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_page)>>('spine_array_atlas_page_dispose');
  late final _spine_array_atlas_page_dispose =
      _spine_array_atlas_page_disposePtr.asFunction<void Function(spine_array_atlas_page)>();

  void spine_array_atlas_page_clear(
    spine_array_atlas_page array,
  ) {
    return _spine_array_atlas_page_clear(
      array,
    );
  }

  late final _spine_array_atlas_page_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_page)>>('spine_array_atlas_page_clear');
  late final _spine_array_atlas_page_clear =
      _spine_array_atlas_page_clearPtr.asFunction<void Function(spine_array_atlas_page)>();

  int spine_array_atlas_page_get_capacity(
    spine_array_atlas_page array,
  ) {
    return _spine_array_atlas_page_get_capacity(
      array,
    );
  }

  late final _spine_array_atlas_page_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_atlas_page)>>('spine_array_atlas_page_get_capacity');
  late final _spine_array_atlas_page_get_capacity =
      _spine_array_atlas_page_get_capacityPtr.asFunction<int Function(spine_array_atlas_page)>();

  int spine_array_atlas_page_size(
    spine_array_atlas_page array,
  ) {
    return _spine_array_atlas_page_size(
      array,
    );
  }

  late final _spine_array_atlas_page_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_atlas_page)>>('spine_array_atlas_page_size');
  late final _spine_array_atlas_page_size =
      _spine_array_atlas_page_sizePtr.asFunction<int Function(spine_array_atlas_page)>();

  spine_array_atlas_page spine_array_atlas_page_set_size(
    spine_array_atlas_page array,
    int newSize,
    spine_atlas_page defaultValue,
  ) {
    return _spine_array_atlas_page_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_atlas_page_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_atlas_page Function(spine_array_atlas_page, ffi.Size, spine_atlas_page)>>(
          'spine_array_atlas_page_set_size');
  late final _spine_array_atlas_page_set_size = _spine_array_atlas_page_set_sizePtr
      .asFunction<spine_array_atlas_page Function(spine_array_atlas_page, int, spine_atlas_page)>();

  void spine_array_atlas_page_ensure_capacity(
    spine_array_atlas_page array,
    int newCapacity,
  ) {
    return _spine_array_atlas_page_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_atlas_page_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_page, ffi.Size)>>(
          'spine_array_atlas_page_ensure_capacity');
  late final _spine_array_atlas_page_ensure_capacity =
      _spine_array_atlas_page_ensure_capacityPtr.asFunction<void Function(spine_array_atlas_page, int)>();

  void spine_array_atlas_page_add(
    spine_array_atlas_page array,
    spine_atlas_page inValue,
  ) {
    return _spine_array_atlas_page_add(
      array,
      inValue,
    );
  }

  late final _spine_array_atlas_page_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_page, spine_atlas_page)>>(
          'spine_array_atlas_page_add');
  late final _spine_array_atlas_page_add =
      _spine_array_atlas_page_addPtr.asFunction<void Function(spine_array_atlas_page, spine_atlas_page)>();

  void spine_array_atlas_page_add_all(
    spine_array_atlas_page array,
    spine_array_atlas_page inValue,
  ) {
    return _spine_array_atlas_page_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_atlas_page_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_page, spine_array_atlas_page)>>(
          'spine_array_atlas_page_add_all');
  late final _spine_array_atlas_page_add_all =
      _spine_array_atlas_page_add_allPtr.asFunction<void Function(spine_array_atlas_page, spine_array_atlas_page)>();

  void spine_array_atlas_page_clear_and_add_all(
    spine_array_atlas_page array,
    spine_array_atlas_page inValue,
  ) {
    return _spine_array_atlas_page_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_atlas_page_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_page, spine_array_atlas_page)>>(
          'spine_array_atlas_page_clear_and_add_all');
  late final _spine_array_atlas_page_clear_and_add_all = _spine_array_atlas_page_clear_and_add_allPtr
      .asFunction<void Function(spine_array_atlas_page, spine_array_atlas_page)>();

  void spine_array_atlas_page_remove_at(
    spine_array_atlas_page array,
    int inIndex,
  ) {
    return _spine_array_atlas_page_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_atlas_page_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_page, ffi.Size)>>(
          'spine_array_atlas_page_remove_at');
  late final _spine_array_atlas_page_remove_at =
      _spine_array_atlas_page_remove_atPtr.asFunction<void Function(spine_array_atlas_page, int)>();

  bool spine_array_atlas_page_contains(
    spine_array_atlas_page array,
    spine_atlas_page inValue,
  ) {
    return _spine_array_atlas_page_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_atlas_page_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_atlas_page, spine_atlas_page)>>(
          'spine_array_atlas_page_contains');
  late final _spine_array_atlas_page_contains =
      _spine_array_atlas_page_containsPtr.asFunction<bool Function(spine_array_atlas_page, spine_atlas_page)>();

  int spine_array_atlas_page_index_of(
    spine_array_atlas_page array,
    spine_atlas_page inValue,
  ) {
    return _spine_array_atlas_page_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_atlas_page_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_atlas_page, spine_atlas_page)>>(
          'spine_array_atlas_page_index_of');
  late final _spine_array_atlas_page_index_of =
      _spine_array_atlas_page_index_ofPtr.asFunction<int Function(spine_array_atlas_page, spine_atlas_page)>();

  ffi.Pointer<spine_atlas_page> spine_array_atlas_page_buffer(
    spine_array_atlas_page array,
  ) {
    return _spine_array_atlas_page_buffer(
      array,
    );
  }

  late final _spine_array_atlas_page_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_atlas_page> Function(spine_array_atlas_page)>>(
          'spine_array_atlas_page_buffer');
  late final _spine_array_atlas_page_buffer =
      _spine_array_atlas_page_bufferPtr.asFunction<ffi.Pointer<spine_atlas_page> Function(spine_array_atlas_page)>();

  spine_array_atlas_region spine_array_atlas_region_create() {
    return _spine_array_atlas_region_create();
  }

  late final _spine_array_atlas_region_createPtr =
      _lookup<ffi.NativeFunction<spine_array_atlas_region Function()>>('spine_array_atlas_region_create');
  late final _spine_array_atlas_region_create =
      _spine_array_atlas_region_createPtr.asFunction<spine_array_atlas_region Function()>();

  spine_array_atlas_region spine_array_atlas_region_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_atlas_region_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_atlas_region_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_atlas_region Function(ffi.Size)>>(
          'spine_array_atlas_region_create_with_capacity');
  late final _spine_array_atlas_region_create_with_capacity =
      _spine_array_atlas_region_create_with_capacityPtr.asFunction<spine_array_atlas_region Function(int)>();

  void spine_array_atlas_region_dispose(
    spine_array_atlas_region array,
  ) {
    return _spine_array_atlas_region_dispose(
      array,
    );
  }

  late final _spine_array_atlas_region_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_region)>>('spine_array_atlas_region_dispose');
  late final _spine_array_atlas_region_dispose =
      _spine_array_atlas_region_disposePtr.asFunction<void Function(spine_array_atlas_region)>();

  void spine_array_atlas_region_clear(
    spine_array_atlas_region array,
  ) {
    return _spine_array_atlas_region_clear(
      array,
    );
  }

  late final _spine_array_atlas_region_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_region)>>('spine_array_atlas_region_clear');
  late final _spine_array_atlas_region_clear =
      _spine_array_atlas_region_clearPtr.asFunction<void Function(spine_array_atlas_region)>();

  int spine_array_atlas_region_get_capacity(
    spine_array_atlas_region array,
  ) {
    return _spine_array_atlas_region_get_capacity(
      array,
    );
  }

  late final _spine_array_atlas_region_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_atlas_region)>>('spine_array_atlas_region_get_capacity');
  late final _spine_array_atlas_region_get_capacity =
      _spine_array_atlas_region_get_capacityPtr.asFunction<int Function(spine_array_atlas_region)>();

  int spine_array_atlas_region_size(
    spine_array_atlas_region array,
  ) {
    return _spine_array_atlas_region_size(
      array,
    );
  }

  late final _spine_array_atlas_region_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_atlas_region)>>('spine_array_atlas_region_size');
  late final _spine_array_atlas_region_size =
      _spine_array_atlas_region_sizePtr.asFunction<int Function(spine_array_atlas_region)>();

  spine_array_atlas_region spine_array_atlas_region_set_size(
    spine_array_atlas_region array,
    int newSize,
    spine_atlas_region defaultValue,
  ) {
    return _spine_array_atlas_region_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_atlas_region_set_sizePtr = _lookup<
          ffi
          .NativeFunction<spine_array_atlas_region Function(spine_array_atlas_region, ffi.Size, spine_atlas_region)>>(
      'spine_array_atlas_region_set_size');
  late final _spine_array_atlas_region_set_size = _spine_array_atlas_region_set_sizePtr
      .asFunction<spine_array_atlas_region Function(spine_array_atlas_region, int, spine_atlas_region)>();

  void spine_array_atlas_region_ensure_capacity(
    spine_array_atlas_region array,
    int newCapacity,
  ) {
    return _spine_array_atlas_region_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_atlas_region_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_region, ffi.Size)>>(
          'spine_array_atlas_region_ensure_capacity');
  late final _spine_array_atlas_region_ensure_capacity =
      _spine_array_atlas_region_ensure_capacityPtr.asFunction<void Function(spine_array_atlas_region, int)>();

  void spine_array_atlas_region_add(
    spine_array_atlas_region array,
    spine_atlas_region inValue,
  ) {
    return _spine_array_atlas_region_add(
      array,
      inValue,
    );
  }

  late final _spine_array_atlas_region_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_region, spine_atlas_region)>>(
          'spine_array_atlas_region_add');
  late final _spine_array_atlas_region_add =
      _spine_array_atlas_region_addPtr.asFunction<void Function(spine_array_atlas_region, spine_atlas_region)>();

  void spine_array_atlas_region_add_all(
    spine_array_atlas_region array,
    spine_array_atlas_region inValue,
  ) {
    return _spine_array_atlas_region_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_atlas_region_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_region, spine_array_atlas_region)>>(
          'spine_array_atlas_region_add_all');
  late final _spine_array_atlas_region_add_all = _spine_array_atlas_region_add_allPtr
      .asFunction<void Function(spine_array_atlas_region, spine_array_atlas_region)>();

  void spine_array_atlas_region_clear_and_add_all(
    spine_array_atlas_region array,
    spine_array_atlas_region inValue,
  ) {
    return _spine_array_atlas_region_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_atlas_region_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_region, spine_array_atlas_region)>>(
          'spine_array_atlas_region_clear_and_add_all');
  late final _spine_array_atlas_region_clear_and_add_all = _spine_array_atlas_region_clear_and_add_allPtr
      .asFunction<void Function(spine_array_atlas_region, spine_array_atlas_region)>();

  void spine_array_atlas_region_remove_at(
    spine_array_atlas_region array,
    int inIndex,
  ) {
    return _spine_array_atlas_region_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_atlas_region_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_atlas_region, ffi.Size)>>(
          'spine_array_atlas_region_remove_at');
  late final _spine_array_atlas_region_remove_at =
      _spine_array_atlas_region_remove_atPtr.asFunction<void Function(spine_array_atlas_region, int)>();

  bool spine_array_atlas_region_contains(
    spine_array_atlas_region array,
    spine_atlas_region inValue,
  ) {
    return _spine_array_atlas_region_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_atlas_region_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_atlas_region, spine_atlas_region)>>(
          'spine_array_atlas_region_contains');
  late final _spine_array_atlas_region_contains =
      _spine_array_atlas_region_containsPtr.asFunction<bool Function(spine_array_atlas_region, spine_atlas_region)>();

  int spine_array_atlas_region_index_of(
    spine_array_atlas_region array,
    spine_atlas_region inValue,
  ) {
    return _spine_array_atlas_region_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_atlas_region_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_atlas_region, spine_atlas_region)>>(
          'spine_array_atlas_region_index_of');
  late final _spine_array_atlas_region_index_of =
      _spine_array_atlas_region_index_ofPtr.asFunction<int Function(spine_array_atlas_region, spine_atlas_region)>();

  ffi.Pointer<spine_atlas_region> spine_array_atlas_region_buffer(
    spine_array_atlas_region array,
  ) {
    return _spine_array_atlas_region_buffer(
      array,
    );
  }

  late final _spine_array_atlas_region_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_atlas_region> Function(spine_array_atlas_region)>>(
          'spine_array_atlas_region_buffer');
  late final _spine_array_atlas_region_buffer = _spine_array_atlas_region_bufferPtr
      .asFunction<ffi.Pointer<spine_atlas_region> Function(spine_array_atlas_region)>();

  spine_array_attachment spine_array_attachment_create() {
    return _spine_array_attachment_create();
  }

  late final _spine_array_attachment_createPtr =
      _lookup<ffi.NativeFunction<spine_array_attachment Function()>>('spine_array_attachment_create');
  late final _spine_array_attachment_create =
      _spine_array_attachment_createPtr.asFunction<spine_array_attachment Function()>();

  spine_array_attachment spine_array_attachment_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_attachment_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_attachment_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_attachment Function(ffi.Size)>>(
          'spine_array_attachment_create_with_capacity');
  late final _spine_array_attachment_create_with_capacity =
      _spine_array_attachment_create_with_capacityPtr.asFunction<spine_array_attachment Function(int)>();

  void spine_array_attachment_dispose(
    spine_array_attachment array,
  ) {
    return _spine_array_attachment_dispose(
      array,
    );
  }

  late final _spine_array_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_attachment)>>('spine_array_attachment_dispose');
  late final _spine_array_attachment_dispose =
      _spine_array_attachment_disposePtr.asFunction<void Function(spine_array_attachment)>();

  void spine_array_attachment_clear(
    spine_array_attachment array,
  ) {
    return _spine_array_attachment_clear(
      array,
    );
  }

  late final _spine_array_attachment_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_attachment)>>('spine_array_attachment_clear');
  late final _spine_array_attachment_clear =
      _spine_array_attachment_clearPtr.asFunction<void Function(spine_array_attachment)>();

  int spine_array_attachment_get_capacity(
    spine_array_attachment array,
  ) {
    return _spine_array_attachment_get_capacity(
      array,
    );
  }

  late final _spine_array_attachment_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_attachment)>>('spine_array_attachment_get_capacity');
  late final _spine_array_attachment_get_capacity =
      _spine_array_attachment_get_capacityPtr.asFunction<int Function(spine_array_attachment)>();

  int spine_array_attachment_size(
    spine_array_attachment array,
  ) {
    return _spine_array_attachment_size(
      array,
    );
  }

  late final _spine_array_attachment_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_attachment)>>('spine_array_attachment_size');
  late final _spine_array_attachment_size =
      _spine_array_attachment_sizePtr.asFunction<int Function(spine_array_attachment)>();

  spine_array_attachment spine_array_attachment_set_size(
    spine_array_attachment array,
    int newSize,
    spine_attachment defaultValue,
  ) {
    return _spine_array_attachment_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_attachment_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_attachment Function(spine_array_attachment, ffi.Size, spine_attachment)>>(
          'spine_array_attachment_set_size');
  late final _spine_array_attachment_set_size = _spine_array_attachment_set_sizePtr
      .asFunction<spine_array_attachment Function(spine_array_attachment, int, spine_attachment)>();

  void spine_array_attachment_ensure_capacity(
    spine_array_attachment array,
    int newCapacity,
  ) {
    return _spine_array_attachment_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_attachment_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_attachment, ffi.Size)>>(
          'spine_array_attachment_ensure_capacity');
  late final _spine_array_attachment_ensure_capacity =
      _spine_array_attachment_ensure_capacityPtr.asFunction<void Function(spine_array_attachment, int)>();

  void spine_array_attachment_add(
    spine_array_attachment array,
    spine_attachment inValue,
  ) {
    return _spine_array_attachment_add(
      array,
      inValue,
    );
  }

  late final _spine_array_attachment_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_attachment, spine_attachment)>>(
          'spine_array_attachment_add');
  late final _spine_array_attachment_add =
      _spine_array_attachment_addPtr.asFunction<void Function(spine_array_attachment, spine_attachment)>();

  void spine_array_attachment_add_all(
    spine_array_attachment array,
    spine_array_attachment inValue,
  ) {
    return _spine_array_attachment_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_attachment_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_attachment, spine_array_attachment)>>(
          'spine_array_attachment_add_all');
  late final _spine_array_attachment_add_all =
      _spine_array_attachment_add_allPtr.asFunction<void Function(spine_array_attachment, spine_array_attachment)>();

  void spine_array_attachment_clear_and_add_all(
    spine_array_attachment array,
    spine_array_attachment inValue,
  ) {
    return _spine_array_attachment_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_attachment_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_attachment, spine_array_attachment)>>(
          'spine_array_attachment_clear_and_add_all');
  late final _spine_array_attachment_clear_and_add_all = _spine_array_attachment_clear_and_add_allPtr
      .asFunction<void Function(spine_array_attachment, spine_array_attachment)>();

  void spine_array_attachment_remove_at(
    spine_array_attachment array,
    int inIndex,
  ) {
    return _spine_array_attachment_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_attachment_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_attachment, ffi.Size)>>(
          'spine_array_attachment_remove_at');
  late final _spine_array_attachment_remove_at =
      _spine_array_attachment_remove_atPtr.asFunction<void Function(spine_array_attachment, int)>();

  bool spine_array_attachment_contains(
    spine_array_attachment array,
    spine_attachment inValue,
  ) {
    return _spine_array_attachment_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_attachment_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_attachment, spine_attachment)>>(
          'spine_array_attachment_contains');
  late final _spine_array_attachment_contains =
      _spine_array_attachment_containsPtr.asFunction<bool Function(spine_array_attachment, spine_attachment)>();

  int spine_array_attachment_index_of(
    spine_array_attachment array,
    spine_attachment inValue,
  ) {
    return _spine_array_attachment_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_attachment_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_attachment, spine_attachment)>>(
          'spine_array_attachment_index_of');
  late final _spine_array_attachment_index_of =
      _spine_array_attachment_index_ofPtr.asFunction<int Function(spine_array_attachment, spine_attachment)>();

  ffi.Pointer<spine_attachment> spine_array_attachment_buffer(
    spine_array_attachment array,
  ) {
    return _spine_array_attachment_buffer(
      array,
    );
  }

  late final _spine_array_attachment_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_attachment> Function(spine_array_attachment)>>(
          'spine_array_attachment_buffer');
  late final _spine_array_attachment_buffer =
      _spine_array_attachment_bufferPtr.asFunction<ffi.Pointer<spine_attachment> Function(spine_array_attachment)>();

  spine_array_bone spine_array_bone_create() {
    return _spine_array_bone_create();
  }

  late final _spine_array_bone_createPtr =
      _lookup<ffi.NativeFunction<spine_array_bone Function()>>('spine_array_bone_create');
  late final _spine_array_bone_create = _spine_array_bone_createPtr.asFunction<spine_array_bone Function()>();

  spine_array_bone spine_array_bone_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_bone_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_bone_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_bone Function(ffi.Size)>>('spine_array_bone_create_with_capacity');
  late final _spine_array_bone_create_with_capacity =
      _spine_array_bone_create_with_capacityPtr.asFunction<spine_array_bone Function(int)>();

  void spine_array_bone_dispose(
    spine_array_bone array,
  ) {
    return _spine_array_bone_dispose(
      array,
    );
  }

  late final _spine_array_bone_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone)>>('spine_array_bone_dispose');
  late final _spine_array_bone_dispose = _spine_array_bone_disposePtr.asFunction<void Function(spine_array_bone)>();

  void spine_array_bone_clear(
    spine_array_bone array,
  ) {
    return _spine_array_bone_clear(
      array,
    );
  }

  late final _spine_array_bone_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone)>>('spine_array_bone_clear');
  late final _spine_array_bone_clear = _spine_array_bone_clearPtr.asFunction<void Function(spine_array_bone)>();

  int spine_array_bone_get_capacity(
    spine_array_bone array,
  ) {
    return _spine_array_bone_get_capacity(
      array,
    );
  }

  late final _spine_array_bone_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_bone)>>('spine_array_bone_get_capacity');
  late final _spine_array_bone_get_capacity =
      _spine_array_bone_get_capacityPtr.asFunction<int Function(spine_array_bone)>();

  int spine_array_bone_size(
    spine_array_bone array,
  ) {
    return _spine_array_bone_size(
      array,
    );
  }

  late final _spine_array_bone_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_bone)>>('spine_array_bone_size');
  late final _spine_array_bone_size = _spine_array_bone_sizePtr.asFunction<int Function(spine_array_bone)>();

  spine_array_bone spine_array_bone_set_size(
    spine_array_bone array,
    int newSize,
    spine_bone defaultValue,
  ) {
    return _spine_array_bone_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_bone_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_bone Function(spine_array_bone, ffi.Size, spine_bone)>>(
          'spine_array_bone_set_size');
  late final _spine_array_bone_set_size =
      _spine_array_bone_set_sizePtr.asFunction<spine_array_bone Function(spine_array_bone, int, spine_bone)>();

  void spine_array_bone_ensure_capacity(
    spine_array_bone array,
    int newCapacity,
  ) {
    return _spine_array_bone_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_bone_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone, ffi.Size)>>('spine_array_bone_ensure_capacity');
  late final _spine_array_bone_ensure_capacity =
      _spine_array_bone_ensure_capacityPtr.asFunction<void Function(spine_array_bone, int)>();

  void spine_array_bone_add(
    spine_array_bone array,
    spine_bone inValue,
  ) {
    return _spine_array_bone_add(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone, spine_bone)>>('spine_array_bone_add');
  late final _spine_array_bone_add = _spine_array_bone_addPtr.asFunction<void Function(spine_array_bone, spine_bone)>();

  void spine_array_bone_add_all(
    spine_array_bone array,
    spine_array_bone inValue,
  ) {
    return _spine_array_bone_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone, spine_array_bone)>>('spine_array_bone_add_all');
  late final _spine_array_bone_add_all =
      _spine_array_bone_add_allPtr.asFunction<void Function(spine_array_bone, spine_array_bone)>();

  void spine_array_bone_clear_and_add_all(
    spine_array_bone array,
    spine_array_bone inValue,
  ) {
    return _spine_array_bone_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone, spine_array_bone)>>(
          'spine_array_bone_clear_and_add_all');
  late final _spine_array_bone_clear_and_add_all =
      _spine_array_bone_clear_and_add_allPtr.asFunction<void Function(spine_array_bone, spine_array_bone)>();

  void spine_array_bone_remove_at(
    spine_array_bone array,
    int inIndex,
  ) {
    return _spine_array_bone_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_bone_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone, ffi.Size)>>('spine_array_bone_remove_at');
  late final _spine_array_bone_remove_at =
      _spine_array_bone_remove_atPtr.asFunction<void Function(spine_array_bone, int)>();

  bool spine_array_bone_contains(
    spine_array_bone array,
    spine_bone inValue,
  ) {
    return _spine_array_bone_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_bone, spine_bone)>>('spine_array_bone_contains');
  late final _spine_array_bone_contains =
      _spine_array_bone_containsPtr.asFunction<bool Function(spine_array_bone, spine_bone)>();

  int spine_array_bone_index_of(
    spine_array_bone array,
    spine_bone inValue,
  ) {
    return _spine_array_bone_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_bone, spine_bone)>>('spine_array_bone_index_of');
  late final _spine_array_bone_index_of =
      _spine_array_bone_index_ofPtr.asFunction<int Function(spine_array_bone, spine_bone)>();

  ffi.Pointer<spine_bone> spine_array_bone_buffer(
    spine_array_bone array,
  ) {
    return _spine_array_bone_buffer(
      array,
    );
  }

  late final _spine_array_bone_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_bone> Function(spine_array_bone)>>('spine_array_bone_buffer');
  late final _spine_array_bone_buffer =
      _spine_array_bone_bufferPtr.asFunction<ffi.Pointer<spine_bone> Function(spine_array_bone)>();

  spine_array_bone_data spine_array_bone_data_create() {
    return _spine_array_bone_data_create();
  }

  late final _spine_array_bone_data_createPtr =
      _lookup<ffi.NativeFunction<spine_array_bone_data Function()>>('spine_array_bone_data_create');
  late final _spine_array_bone_data_create =
      _spine_array_bone_data_createPtr.asFunction<spine_array_bone_data Function()>();

  spine_array_bone_data spine_array_bone_data_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_bone_data_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_bone_data_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_bone_data Function(ffi.Size)>>(
          'spine_array_bone_data_create_with_capacity');
  late final _spine_array_bone_data_create_with_capacity =
      _spine_array_bone_data_create_with_capacityPtr.asFunction<spine_array_bone_data Function(int)>();

  void spine_array_bone_data_dispose(
    spine_array_bone_data array,
  ) {
    return _spine_array_bone_data_dispose(
      array,
    );
  }

  late final _spine_array_bone_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_data)>>('spine_array_bone_data_dispose');
  late final _spine_array_bone_data_dispose =
      _spine_array_bone_data_disposePtr.asFunction<void Function(spine_array_bone_data)>();

  void spine_array_bone_data_clear(
    spine_array_bone_data array,
  ) {
    return _spine_array_bone_data_clear(
      array,
    );
  }

  late final _spine_array_bone_data_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_data)>>('spine_array_bone_data_clear');
  late final _spine_array_bone_data_clear =
      _spine_array_bone_data_clearPtr.asFunction<void Function(spine_array_bone_data)>();

  int spine_array_bone_data_get_capacity(
    spine_array_bone_data array,
  ) {
    return _spine_array_bone_data_get_capacity(
      array,
    );
  }

  late final _spine_array_bone_data_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_bone_data)>>('spine_array_bone_data_get_capacity');
  late final _spine_array_bone_data_get_capacity =
      _spine_array_bone_data_get_capacityPtr.asFunction<int Function(spine_array_bone_data)>();

  int spine_array_bone_data_size(
    spine_array_bone_data array,
  ) {
    return _spine_array_bone_data_size(
      array,
    );
  }

  late final _spine_array_bone_data_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_bone_data)>>('spine_array_bone_data_size');
  late final _spine_array_bone_data_size =
      _spine_array_bone_data_sizePtr.asFunction<int Function(spine_array_bone_data)>();

  spine_array_bone_data spine_array_bone_data_set_size(
    spine_array_bone_data array,
    int newSize,
    spine_bone_data defaultValue,
  ) {
    return _spine_array_bone_data_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_bone_data_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_bone_data Function(spine_array_bone_data, ffi.Size, spine_bone_data)>>(
          'spine_array_bone_data_set_size');
  late final _spine_array_bone_data_set_size = _spine_array_bone_data_set_sizePtr
      .asFunction<spine_array_bone_data Function(spine_array_bone_data, int, spine_bone_data)>();

  void spine_array_bone_data_ensure_capacity(
    spine_array_bone_data array,
    int newCapacity,
  ) {
    return _spine_array_bone_data_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_bone_data_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_data, ffi.Size)>>(
          'spine_array_bone_data_ensure_capacity');
  late final _spine_array_bone_data_ensure_capacity =
      _spine_array_bone_data_ensure_capacityPtr.asFunction<void Function(spine_array_bone_data, int)>();

  void spine_array_bone_data_add(
    spine_array_bone_data array,
    spine_bone_data inValue,
  ) {
    return _spine_array_bone_data_add(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_data_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_data, spine_bone_data)>>(
          'spine_array_bone_data_add');
  late final _spine_array_bone_data_add =
      _spine_array_bone_data_addPtr.asFunction<void Function(spine_array_bone_data, spine_bone_data)>();

  void spine_array_bone_data_add_all(
    spine_array_bone_data array,
    spine_array_bone_data inValue,
  ) {
    return _spine_array_bone_data_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_data_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_data, spine_array_bone_data)>>(
          'spine_array_bone_data_add_all');
  late final _spine_array_bone_data_add_all =
      _spine_array_bone_data_add_allPtr.asFunction<void Function(spine_array_bone_data, spine_array_bone_data)>();

  void spine_array_bone_data_clear_and_add_all(
    spine_array_bone_data array,
    spine_array_bone_data inValue,
  ) {
    return _spine_array_bone_data_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_data_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_data, spine_array_bone_data)>>(
          'spine_array_bone_data_clear_and_add_all');
  late final _spine_array_bone_data_clear_and_add_all = _spine_array_bone_data_clear_and_add_allPtr
      .asFunction<void Function(spine_array_bone_data, spine_array_bone_data)>();

  void spine_array_bone_data_remove_at(
    spine_array_bone_data array,
    int inIndex,
  ) {
    return _spine_array_bone_data_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_bone_data_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_data, ffi.Size)>>(
          'spine_array_bone_data_remove_at');
  late final _spine_array_bone_data_remove_at =
      _spine_array_bone_data_remove_atPtr.asFunction<void Function(spine_array_bone_data, int)>();

  bool spine_array_bone_data_contains(
    spine_array_bone_data array,
    spine_bone_data inValue,
  ) {
    return _spine_array_bone_data_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_data_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_bone_data, spine_bone_data)>>(
          'spine_array_bone_data_contains');
  late final _spine_array_bone_data_contains =
      _spine_array_bone_data_containsPtr.asFunction<bool Function(spine_array_bone_data, spine_bone_data)>();

  int spine_array_bone_data_index_of(
    spine_array_bone_data array,
    spine_bone_data inValue,
  ) {
    return _spine_array_bone_data_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_data_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_bone_data, spine_bone_data)>>(
          'spine_array_bone_data_index_of');
  late final _spine_array_bone_data_index_of =
      _spine_array_bone_data_index_ofPtr.asFunction<int Function(spine_array_bone_data, spine_bone_data)>();

  ffi.Pointer<spine_bone_data> spine_array_bone_data_buffer(
    spine_array_bone_data array,
  ) {
    return _spine_array_bone_data_buffer(
      array,
    );
  }

  late final _spine_array_bone_data_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_bone_data> Function(spine_array_bone_data)>>(
          'spine_array_bone_data_buffer');
  late final _spine_array_bone_data_buffer =
      _spine_array_bone_data_bufferPtr.asFunction<ffi.Pointer<spine_bone_data> Function(spine_array_bone_data)>();

  spine_array_bone_pose spine_array_bone_pose_create() {
    return _spine_array_bone_pose_create();
  }

  late final _spine_array_bone_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_array_bone_pose Function()>>('spine_array_bone_pose_create');
  late final _spine_array_bone_pose_create =
      _spine_array_bone_pose_createPtr.asFunction<spine_array_bone_pose Function()>();

  spine_array_bone_pose spine_array_bone_pose_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_bone_pose_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_bone_pose_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_bone_pose Function(ffi.Size)>>(
          'spine_array_bone_pose_create_with_capacity');
  late final _spine_array_bone_pose_create_with_capacity =
      _spine_array_bone_pose_create_with_capacityPtr.asFunction<spine_array_bone_pose Function(int)>();

  void spine_array_bone_pose_dispose(
    spine_array_bone_pose array,
  ) {
    return _spine_array_bone_pose_dispose(
      array,
    );
  }

  late final _spine_array_bone_pose_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_pose)>>('spine_array_bone_pose_dispose');
  late final _spine_array_bone_pose_dispose =
      _spine_array_bone_pose_disposePtr.asFunction<void Function(spine_array_bone_pose)>();

  void spine_array_bone_pose_clear(
    spine_array_bone_pose array,
  ) {
    return _spine_array_bone_pose_clear(
      array,
    );
  }

  late final _spine_array_bone_pose_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_pose)>>('spine_array_bone_pose_clear');
  late final _spine_array_bone_pose_clear =
      _spine_array_bone_pose_clearPtr.asFunction<void Function(spine_array_bone_pose)>();

  int spine_array_bone_pose_get_capacity(
    spine_array_bone_pose array,
  ) {
    return _spine_array_bone_pose_get_capacity(
      array,
    );
  }

  late final _spine_array_bone_pose_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_bone_pose)>>('spine_array_bone_pose_get_capacity');
  late final _spine_array_bone_pose_get_capacity =
      _spine_array_bone_pose_get_capacityPtr.asFunction<int Function(spine_array_bone_pose)>();

  int spine_array_bone_pose_size(
    spine_array_bone_pose array,
  ) {
    return _spine_array_bone_pose_size(
      array,
    );
  }

  late final _spine_array_bone_pose_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_bone_pose)>>('spine_array_bone_pose_size');
  late final _spine_array_bone_pose_size =
      _spine_array_bone_pose_sizePtr.asFunction<int Function(spine_array_bone_pose)>();

  spine_array_bone_pose spine_array_bone_pose_set_size(
    spine_array_bone_pose array,
    int newSize,
    spine_bone_pose defaultValue,
  ) {
    return _spine_array_bone_pose_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_bone_pose_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_bone_pose Function(spine_array_bone_pose, ffi.Size, spine_bone_pose)>>(
          'spine_array_bone_pose_set_size');
  late final _spine_array_bone_pose_set_size = _spine_array_bone_pose_set_sizePtr
      .asFunction<spine_array_bone_pose Function(spine_array_bone_pose, int, spine_bone_pose)>();

  void spine_array_bone_pose_ensure_capacity(
    spine_array_bone_pose array,
    int newCapacity,
  ) {
    return _spine_array_bone_pose_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_bone_pose_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_pose, ffi.Size)>>(
          'spine_array_bone_pose_ensure_capacity');
  late final _spine_array_bone_pose_ensure_capacity =
      _spine_array_bone_pose_ensure_capacityPtr.asFunction<void Function(spine_array_bone_pose, int)>();

  void spine_array_bone_pose_add(
    spine_array_bone_pose array,
    spine_bone_pose inValue,
  ) {
    return _spine_array_bone_pose_add(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_pose_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_pose, spine_bone_pose)>>(
          'spine_array_bone_pose_add');
  late final _spine_array_bone_pose_add =
      _spine_array_bone_pose_addPtr.asFunction<void Function(spine_array_bone_pose, spine_bone_pose)>();

  void spine_array_bone_pose_add_all(
    spine_array_bone_pose array,
    spine_array_bone_pose inValue,
  ) {
    return _spine_array_bone_pose_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_pose_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_pose, spine_array_bone_pose)>>(
          'spine_array_bone_pose_add_all');
  late final _spine_array_bone_pose_add_all =
      _spine_array_bone_pose_add_allPtr.asFunction<void Function(spine_array_bone_pose, spine_array_bone_pose)>();

  void spine_array_bone_pose_clear_and_add_all(
    spine_array_bone_pose array,
    spine_array_bone_pose inValue,
  ) {
    return _spine_array_bone_pose_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_pose_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_pose, spine_array_bone_pose)>>(
          'spine_array_bone_pose_clear_and_add_all');
  late final _spine_array_bone_pose_clear_and_add_all = _spine_array_bone_pose_clear_and_add_allPtr
      .asFunction<void Function(spine_array_bone_pose, spine_array_bone_pose)>();

  void spine_array_bone_pose_remove_at(
    spine_array_bone_pose array,
    int inIndex,
  ) {
    return _spine_array_bone_pose_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_bone_pose_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone_pose, ffi.Size)>>(
          'spine_array_bone_pose_remove_at');
  late final _spine_array_bone_pose_remove_at =
      _spine_array_bone_pose_remove_atPtr.asFunction<void Function(spine_array_bone_pose, int)>();

  bool spine_array_bone_pose_contains(
    spine_array_bone_pose array,
    spine_bone_pose inValue,
  ) {
    return _spine_array_bone_pose_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_pose_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_bone_pose, spine_bone_pose)>>(
          'spine_array_bone_pose_contains');
  late final _spine_array_bone_pose_contains =
      _spine_array_bone_pose_containsPtr.asFunction<bool Function(spine_array_bone_pose, spine_bone_pose)>();

  int spine_array_bone_pose_index_of(
    spine_array_bone_pose array,
    spine_bone_pose inValue,
  ) {
    return _spine_array_bone_pose_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_bone_pose_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_bone_pose, spine_bone_pose)>>(
          'spine_array_bone_pose_index_of');
  late final _spine_array_bone_pose_index_of =
      _spine_array_bone_pose_index_ofPtr.asFunction<int Function(spine_array_bone_pose, spine_bone_pose)>();

  ffi.Pointer<spine_bone_pose> spine_array_bone_pose_buffer(
    spine_array_bone_pose array,
  ) {
    return _spine_array_bone_pose_buffer(
      array,
    );
  }

  late final _spine_array_bone_pose_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_bone_pose> Function(spine_array_bone_pose)>>(
          'spine_array_bone_pose_buffer');
  late final _spine_array_bone_pose_buffer =
      _spine_array_bone_pose_bufferPtr.asFunction<ffi.Pointer<spine_bone_pose> Function(spine_array_bone_pose)>();

  spine_array_bounding_box_attachment spine_array_bounding_box_attachment_create() {
    return _spine_array_bounding_box_attachment_create();
  }

  late final _spine_array_bounding_box_attachment_createPtr =
      _lookup<ffi.NativeFunction<spine_array_bounding_box_attachment Function()>>(
          'spine_array_bounding_box_attachment_create');
  late final _spine_array_bounding_box_attachment_create =
      _spine_array_bounding_box_attachment_createPtr.asFunction<spine_array_bounding_box_attachment Function()>();

  spine_array_bounding_box_attachment spine_array_bounding_box_attachment_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_bounding_box_attachment_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_bounding_box_attachment_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_bounding_box_attachment Function(ffi.Size)>>(
          'spine_array_bounding_box_attachment_create_with_capacity');
  late final _spine_array_bounding_box_attachment_create_with_capacity =
      _spine_array_bounding_box_attachment_create_with_capacityPtr
          .asFunction<spine_array_bounding_box_attachment Function(int)>();

  void spine_array_bounding_box_attachment_dispose(
    spine_array_bounding_box_attachment array,
  ) {
    return _spine_array_bounding_box_attachment_dispose(
      array,
    );
  }

  late final _spine_array_bounding_box_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bounding_box_attachment)>>(
          'spine_array_bounding_box_attachment_dispose');
  late final _spine_array_bounding_box_attachment_dispose =
      _spine_array_bounding_box_attachment_disposePtr.asFunction<void Function(spine_array_bounding_box_attachment)>();

  void spine_array_bounding_box_attachment_clear(
    spine_array_bounding_box_attachment array,
  ) {
    return _spine_array_bounding_box_attachment_clear(
      array,
    );
  }

  late final _spine_array_bounding_box_attachment_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bounding_box_attachment)>>(
          'spine_array_bounding_box_attachment_clear');
  late final _spine_array_bounding_box_attachment_clear =
      _spine_array_bounding_box_attachment_clearPtr.asFunction<void Function(spine_array_bounding_box_attachment)>();

  int spine_array_bounding_box_attachment_get_capacity(
    spine_array_bounding_box_attachment array,
  ) {
    return _spine_array_bounding_box_attachment_get_capacity(
      array,
    );
  }

  late final _spine_array_bounding_box_attachment_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_bounding_box_attachment)>>(
          'spine_array_bounding_box_attachment_get_capacity');
  late final _spine_array_bounding_box_attachment_get_capacity = _spine_array_bounding_box_attachment_get_capacityPtr
      .asFunction<int Function(spine_array_bounding_box_attachment)>();

  int spine_array_bounding_box_attachment_size(
    spine_array_bounding_box_attachment array,
  ) {
    return _spine_array_bounding_box_attachment_size(
      array,
    );
  }

  late final _spine_array_bounding_box_attachment_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_bounding_box_attachment)>>(
          'spine_array_bounding_box_attachment_size');
  late final _spine_array_bounding_box_attachment_size =
      _spine_array_bounding_box_attachment_sizePtr.asFunction<int Function(spine_array_bounding_box_attachment)>();

  spine_array_bounding_box_attachment spine_array_bounding_box_attachment_set_size(
    spine_array_bounding_box_attachment array,
    int newSize,
    spine_bounding_box_attachment defaultValue,
  ) {
    return _spine_array_bounding_box_attachment_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_bounding_box_attachment_set_sizePtr = _lookup<
      ffi.NativeFunction<
          spine_array_bounding_box_attachment Function(spine_array_bounding_box_attachment, ffi.Size,
              spine_bounding_box_attachment)>>('spine_array_bounding_box_attachment_set_size');
  late final _spine_array_bounding_box_attachment_set_size =
      _spine_array_bounding_box_attachment_set_sizePtr.asFunction<
          spine_array_bounding_box_attachment Function(
              spine_array_bounding_box_attachment, int, spine_bounding_box_attachment)>();

  void spine_array_bounding_box_attachment_ensure_capacity(
    spine_array_bounding_box_attachment array,
    int newCapacity,
  ) {
    return _spine_array_bounding_box_attachment_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_bounding_box_attachment_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bounding_box_attachment, ffi.Size)>>(
          'spine_array_bounding_box_attachment_ensure_capacity');
  late final _spine_array_bounding_box_attachment_ensure_capacity =
      _spine_array_bounding_box_attachment_ensure_capacityPtr
          .asFunction<void Function(spine_array_bounding_box_attachment, int)>();

  void spine_array_bounding_box_attachment_add(
    spine_array_bounding_box_attachment array,
    spine_bounding_box_attachment inValue,
  ) {
    return _spine_array_bounding_box_attachment_add(
      array,
      inValue,
    );
  }

  late final _spine_array_bounding_box_attachment_addPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_array_bounding_box_attachment, spine_bounding_box_attachment)>>(
      'spine_array_bounding_box_attachment_add');
  late final _spine_array_bounding_box_attachment_add = _spine_array_bounding_box_attachment_addPtr
      .asFunction<void Function(spine_array_bounding_box_attachment, spine_bounding_box_attachment)>();

  void spine_array_bounding_box_attachment_add_all(
    spine_array_bounding_box_attachment array,
    spine_array_bounding_box_attachment inValue,
  ) {
    return _spine_array_bounding_box_attachment_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_bounding_box_attachment_add_allPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_array_bounding_box_attachment, spine_array_bounding_box_attachment)>>(
      'spine_array_bounding_box_attachment_add_all');
  late final _spine_array_bounding_box_attachment_add_all = _spine_array_bounding_box_attachment_add_allPtr
      .asFunction<void Function(spine_array_bounding_box_attachment, spine_array_bounding_box_attachment)>();

  void spine_array_bounding_box_attachment_clear_and_add_all(
    spine_array_bounding_box_attachment array,
    spine_array_bounding_box_attachment inValue,
  ) {
    return _spine_array_bounding_box_attachment_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_bounding_box_attachment_clear_and_add_allPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_array_bounding_box_attachment, spine_array_bounding_box_attachment)>>(
      'spine_array_bounding_box_attachment_clear_and_add_all');
  late final _spine_array_bounding_box_attachment_clear_and_add_all =
      _spine_array_bounding_box_attachment_clear_and_add_allPtr
          .asFunction<void Function(spine_array_bounding_box_attachment, spine_array_bounding_box_attachment)>();

  void spine_array_bounding_box_attachment_remove_at(
    spine_array_bounding_box_attachment array,
    int inIndex,
  ) {
    return _spine_array_bounding_box_attachment_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_bounding_box_attachment_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bounding_box_attachment, ffi.Size)>>(
          'spine_array_bounding_box_attachment_remove_at');
  late final _spine_array_bounding_box_attachment_remove_at = _spine_array_bounding_box_attachment_remove_atPtr
      .asFunction<void Function(spine_array_bounding_box_attachment, int)>();

  bool spine_array_bounding_box_attachment_contains(
    spine_array_bounding_box_attachment array,
    spine_bounding_box_attachment inValue,
  ) {
    return _spine_array_bounding_box_attachment_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_bounding_box_attachment_containsPtr = _lookup<
          ffi.NativeFunction<ffi.Bool Function(spine_array_bounding_box_attachment, spine_bounding_box_attachment)>>(
      'spine_array_bounding_box_attachment_contains');
  late final _spine_array_bounding_box_attachment_contains = _spine_array_bounding_box_attachment_containsPtr
      .asFunction<bool Function(spine_array_bounding_box_attachment, spine_bounding_box_attachment)>();

  int spine_array_bounding_box_attachment_index_of(
    spine_array_bounding_box_attachment array,
    spine_bounding_box_attachment inValue,
  ) {
    return _spine_array_bounding_box_attachment_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_bounding_box_attachment_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_bounding_box_attachment, spine_bounding_box_attachment)>>(
          'spine_array_bounding_box_attachment_index_of');
  late final _spine_array_bounding_box_attachment_index_of = _spine_array_bounding_box_attachment_index_ofPtr
      .asFunction<int Function(spine_array_bounding_box_attachment, spine_bounding_box_attachment)>();

  ffi.Pointer<spine_bounding_box_attachment> spine_array_bounding_box_attachment_buffer(
    spine_array_bounding_box_attachment array,
  ) {
    return _spine_array_bounding_box_attachment_buffer(
      array,
    );
  }

  late final _spine_array_bounding_box_attachment_bufferPtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<spine_bounding_box_attachment> Function(spine_array_bounding_box_attachment)>>(
      'spine_array_bounding_box_attachment_buffer');
  late final _spine_array_bounding_box_attachment_buffer = _spine_array_bounding_box_attachment_bufferPtr
      .asFunction<ffi.Pointer<spine_bounding_box_attachment> Function(spine_array_bounding_box_attachment)>();

  spine_array_constraint spine_array_constraint_create() {
    return _spine_array_constraint_create();
  }

  late final _spine_array_constraint_createPtr =
      _lookup<ffi.NativeFunction<spine_array_constraint Function()>>('spine_array_constraint_create');
  late final _spine_array_constraint_create =
      _spine_array_constraint_createPtr.asFunction<spine_array_constraint Function()>();

  spine_array_constraint spine_array_constraint_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_constraint_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_constraint_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_constraint Function(ffi.Size)>>(
          'spine_array_constraint_create_with_capacity');
  late final _spine_array_constraint_create_with_capacity =
      _spine_array_constraint_create_with_capacityPtr.asFunction<spine_array_constraint Function(int)>();

  void spine_array_constraint_dispose(
    spine_array_constraint array,
  ) {
    return _spine_array_constraint_dispose(
      array,
    );
  }

  late final _spine_array_constraint_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint)>>('spine_array_constraint_dispose');
  late final _spine_array_constraint_dispose =
      _spine_array_constraint_disposePtr.asFunction<void Function(spine_array_constraint)>();

  void spine_array_constraint_clear(
    spine_array_constraint array,
  ) {
    return _spine_array_constraint_clear(
      array,
    );
  }

  late final _spine_array_constraint_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint)>>('spine_array_constraint_clear');
  late final _spine_array_constraint_clear =
      _spine_array_constraint_clearPtr.asFunction<void Function(spine_array_constraint)>();

  int spine_array_constraint_get_capacity(
    spine_array_constraint array,
  ) {
    return _spine_array_constraint_get_capacity(
      array,
    );
  }

  late final _spine_array_constraint_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_constraint)>>('spine_array_constraint_get_capacity');
  late final _spine_array_constraint_get_capacity =
      _spine_array_constraint_get_capacityPtr.asFunction<int Function(spine_array_constraint)>();

  int spine_array_constraint_size(
    spine_array_constraint array,
  ) {
    return _spine_array_constraint_size(
      array,
    );
  }

  late final _spine_array_constraint_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_constraint)>>('spine_array_constraint_size');
  late final _spine_array_constraint_size =
      _spine_array_constraint_sizePtr.asFunction<int Function(spine_array_constraint)>();

  spine_array_constraint spine_array_constraint_set_size(
    spine_array_constraint array,
    int newSize,
    spine_constraint defaultValue,
  ) {
    return _spine_array_constraint_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_constraint_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_constraint Function(spine_array_constraint, ffi.Size, spine_constraint)>>(
          'spine_array_constraint_set_size');
  late final _spine_array_constraint_set_size = _spine_array_constraint_set_sizePtr
      .asFunction<spine_array_constraint Function(spine_array_constraint, int, spine_constraint)>();

  void spine_array_constraint_ensure_capacity(
    spine_array_constraint array,
    int newCapacity,
  ) {
    return _spine_array_constraint_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_constraint_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint, ffi.Size)>>(
          'spine_array_constraint_ensure_capacity');
  late final _spine_array_constraint_ensure_capacity =
      _spine_array_constraint_ensure_capacityPtr.asFunction<void Function(spine_array_constraint, int)>();

  void spine_array_constraint_add(
    spine_array_constraint array,
    spine_constraint inValue,
  ) {
    return _spine_array_constraint_add(
      array,
      inValue,
    );
  }

  late final _spine_array_constraint_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint, spine_constraint)>>(
          'spine_array_constraint_add');
  late final _spine_array_constraint_add =
      _spine_array_constraint_addPtr.asFunction<void Function(spine_array_constraint, spine_constraint)>();

  void spine_array_constraint_add_all(
    spine_array_constraint array,
    spine_array_constraint inValue,
  ) {
    return _spine_array_constraint_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_constraint_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint, spine_array_constraint)>>(
          'spine_array_constraint_add_all');
  late final _spine_array_constraint_add_all =
      _spine_array_constraint_add_allPtr.asFunction<void Function(spine_array_constraint, spine_array_constraint)>();

  void spine_array_constraint_clear_and_add_all(
    spine_array_constraint array,
    spine_array_constraint inValue,
  ) {
    return _spine_array_constraint_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_constraint_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint, spine_array_constraint)>>(
          'spine_array_constraint_clear_and_add_all');
  late final _spine_array_constraint_clear_and_add_all = _spine_array_constraint_clear_and_add_allPtr
      .asFunction<void Function(spine_array_constraint, spine_array_constraint)>();

  void spine_array_constraint_remove_at(
    spine_array_constraint array,
    int inIndex,
  ) {
    return _spine_array_constraint_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_constraint_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint, ffi.Size)>>(
          'spine_array_constraint_remove_at');
  late final _spine_array_constraint_remove_at =
      _spine_array_constraint_remove_atPtr.asFunction<void Function(spine_array_constraint, int)>();

  bool spine_array_constraint_contains(
    spine_array_constraint array,
    spine_constraint inValue,
  ) {
    return _spine_array_constraint_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_constraint_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_constraint, spine_constraint)>>(
          'spine_array_constraint_contains');
  late final _spine_array_constraint_contains =
      _spine_array_constraint_containsPtr.asFunction<bool Function(spine_array_constraint, spine_constraint)>();

  int spine_array_constraint_index_of(
    spine_array_constraint array,
    spine_constraint inValue,
  ) {
    return _spine_array_constraint_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_constraint_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_constraint, spine_constraint)>>(
          'spine_array_constraint_index_of');
  late final _spine_array_constraint_index_of =
      _spine_array_constraint_index_ofPtr.asFunction<int Function(spine_array_constraint, spine_constraint)>();

  ffi.Pointer<spine_constraint> spine_array_constraint_buffer(
    spine_array_constraint array,
  ) {
    return _spine_array_constraint_buffer(
      array,
    );
  }

  late final _spine_array_constraint_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_constraint> Function(spine_array_constraint)>>(
          'spine_array_constraint_buffer');
  late final _spine_array_constraint_buffer =
      _spine_array_constraint_bufferPtr.asFunction<ffi.Pointer<spine_constraint> Function(spine_array_constraint)>();

  spine_array_constraint_data spine_array_constraint_data_create() {
    return _spine_array_constraint_data_create();
  }

  late final _spine_array_constraint_data_createPtr =
      _lookup<ffi.NativeFunction<spine_array_constraint_data Function()>>('spine_array_constraint_data_create');
  late final _spine_array_constraint_data_create =
      _spine_array_constraint_data_createPtr.asFunction<spine_array_constraint_data Function()>();

  spine_array_constraint_data spine_array_constraint_data_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_constraint_data_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_constraint_data_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_constraint_data Function(ffi.Size)>>(
          'spine_array_constraint_data_create_with_capacity');
  late final _spine_array_constraint_data_create_with_capacity =
      _spine_array_constraint_data_create_with_capacityPtr.asFunction<spine_array_constraint_data Function(int)>();

  void spine_array_constraint_data_dispose(
    spine_array_constraint_data array,
  ) {
    return _spine_array_constraint_data_dispose(
      array,
    );
  }

  late final _spine_array_constraint_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint_data)>>(
          'spine_array_constraint_data_dispose');
  late final _spine_array_constraint_data_dispose =
      _spine_array_constraint_data_disposePtr.asFunction<void Function(spine_array_constraint_data)>();

  void spine_array_constraint_data_clear(
    spine_array_constraint_data array,
  ) {
    return _spine_array_constraint_data_clear(
      array,
    );
  }

  late final _spine_array_constraint_data_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint_data)>>('spine_array_constraint_data_clear');
  late final _spine_array_constraint_data_clear =
      _spine_array_constraint_data_clearPtr.asFunction<void Function(spine_array_constraint_data)>();

  int spine_array_constraint_data_get_capacity(
    spine_array_constraint_data array,
  ) {
    return _spine_array_constraint_data_get_capacity(
      array,
    );
  }

  late final _spine_array_constraint_data_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_constraint_data)>>(
          'spine_array_constraint_data_get_capacity');
  late final _spine_array_constraint_data_get_capacity =
      _spine_array_constraint_data_get_capacityPtr.asFunction<int Function(spine_array_constraint_data)>();

  int spine_array_constraint_data_size(
    spine_array_constraint_data array,
  ) {
    return _spine_array_constraint_data_size(
      array,
    );
  }

  late final _spine_array_constraint_data_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_constraint_data)>>('spine_array_constraint_data_size');
  late final _spine_array_constraint_data_size =
      _spine_array_constraint_data_sizePtr.asFunction<int Function(spine_array_constraint_data)>();

  spine_array_constraint_data spine_array_constraint_data_set_size(
    spine_array_constraint_data array,
    int newSize,
    spine_constraint_data defaultValue,
  ) {
    return _spine_array_constraint_data_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_constraint_data_set_sizePtr = _lookup<
      ffi.NativeFunction<
          spine_array_constraint_data Function(
              spine_array_constraint_data, ffi.Size, spine_constraint_data)>>('spine_array_constraint_data_set_size');
  late final _spine_array_constraint_data_set_size = _spine_array_constraint_data_set_sizePtr
      .asFunction<spine_array_constraint_data Function(spine_array_constraint_data, int, spine_constraint_data)>();

  void spine_array_constraint_data_ensure_capacity(
    spine_array_constraint_data array,
    int newCapacity,
  ) {
    return _spine_array_constraint_data_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_constraint_data_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint_data, ffi.Size)>>(
          'spine_array_constraint_data_ensure_capacity');
  late final _spine_array_constraint_data_ensure_capacity =
      _spine_array_constraint_data_ensure_capacityPtr.asFunction<void Function(spine_array_constraint_data, int)>();

  void spine_array_constraint_data_add(
    spine_array_constraint_data array,
    spine_constraint_data inValue,
  ) {
    return _spine_array_constraint_data_add(
      array,
      inValue,
    );
  }

  late final _spine_array_constraint_data_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint_data, spine_constraint_data)>>(
          'spine_array_constraint_data_add');
  late final _spine_array_constraint_data_add = _spine_array_constraint_data_addPtr
      .asFunction<void Function(spine_array_constraint_data, spine_constraint_data)>();

  void spine_array_constraint_data_add_all(
    spine_array_constraint_data array,
    spine_array_constraint_data inValue,
  ) {
    return _spine_array_constraint_data_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_constraint_data_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint_data, spine_array_constraint_data)>>(
          'spine_array_constraint_data_add_all');
  late final _spine_array_constraint_data_add_all = _spine_array_constraint_data_add_allPtr
      .asFunction<void Function(spine_array_constraint_data, spine_array_constraint_data)>();

  void spine_array_constraint_data_clear_and_add_all(
    spine_array_constraint_data array,
    spine_array_constraint_data inValue,
  ) {
    return _spine_array_constraint_data_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_constraint_data_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint_data, spine_array_constraint_data)>>(
          'spine_array_constraint_data_clear_and_add_all');
  late final _spine_array_constraint_data_clear_and_add_all = _spine_array_constraint_data_clear_and_add_allPtr
      .asFunction<void Function(spine_array_constraint_data, spine_array_constraint_data)>();

  void spine_array_constraint_data_remove_at(
    spine_array_constraint_data array,
    int inIndex,
  ) {
    return _spine_array_constraint_data_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_constraint_data_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_constraint_data, ffi.Size)>>(
          'spine_array_constraint_data_remove_at');
  late final _spine_array_constraint_data_remove_at =
      _spine_array_constraint_data_remove_atPtr.asFunction<void Function(spine_array_constraint_data, int)>();

  bool spine_array_constraint_data_contains(
    spine_array_constraint_data array,
    spine_constraint_data inValue,
  ) {
    return _spine_array_constraint_data_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_constraint_data_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_constraint_data, spine_constraint_data)>>(
          'spine_array_constraint_data_contains');
  late final _spine_array_constraint_data_contains = _spine_array_constraint_data_containsPtr
      .asFunction<bool Function(spine_array_constraint_data, spine_constraint_data)>();

  int spine_array_constraint_data_index_of(
    spine_array_constraint_data array,
    spine_constraint_data inValue,
  ) {
    return _spine_array_constraint_data_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_constraint_data_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_constraint_data, spine_constraint_data)>>(
          'spine_array_constraint_data_index_of');
  late final _spine_array_constraint_data_index_of = _spine_array_constraint_data_index_ofPtr
      .asFunction<int Function(spine_array_constraint_data, spine_constraint_data)>();

  ffi.Pointer<spine_constraint_data> spine_array_constraint_data_buffer(
    spine_array_constraint_data array,
  ) {
    return _spine_array_constraint_data_buffer(
      array,
    );
  }

  late final _spine_array_constraint_data_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_constraint_data> Function(spine_array_constraint_data)>>(
          'spine_array_constraint_data_buffer');
  late final _spine_array_constraint_data_buffer = _spine_array_constraint_data_bufferPtr
      .asFunction<ffi.Pointer<spine_constraint_data> Function(spine_array_constraint_data)>();

  spine_array_event spine_array_event_create() {
    return _spine_array_event_create();
  }

  late final _spine_array_event_createPtr =
      _lookup<ffi.NativeFunction<spine_array_event Function()>>('spine_array_event_create');
  late final _spine_array_event_create = _spine_array_event_createPtr.asFunction<spine_array_event Function()>();

  spine_array_event spine_array_event_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_event_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_event_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_event Function(ffi.Size)>>('spine_array_event_create_with_capacity');
  late final _spine_array_event_create_with_capacity =
      _spine_array_event_create_with_capacityPtr.asFunction<spine_array_event Function(int)>();

  void spine_array_event_dispose(
    spine_array_event array,
  ) {
    return _spine_array_event_dispose(
      array,
    );
  }

  late final _spine_array_event_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event)>>('spine_array_event_dispose');
  late final _spine_array_event_dispose = _spine_array_event_disposePtr.asFunction<void Function(spine_array_event)>();

  void spine_array_event_clear(
    spine_array_event array,
  ) {
    return _spine_array_event_clear(
      array,
    );
  }

  late final _spine_array_event_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event)>>('spine_array_event_clear');
  late final _spine_array_event_clear = _spine_array_event_clearPtr.asFunction<void Function(spine_array_event)>();

  int spine_array_event_get_capacity(
    spine_array_event array,
  ) {
    return _spine_array_event_get_capacity(
      array,
    );
  }

  late final _spine_array_event_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_event)>>('spine_array_event_get_capacity');
  late final _spine_array_event_get_capacity =
      _spine_array_event_get_capacityPtr.asFunction<int Function(spine_array_event)>();

  int spine_array_event_size(
    spine_array_event array,
  ) {
    return _spine_array_event_size(
      array,
    );
  }

  late final _spine_array_event_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_event)>>('spine_array_event_size');
  late final _spine_array_event_size = _spine_array_event_sizePtr.asFunction<int Function(spine_array_event)>();

  spine_array_event spine_array_event_set_size(
    spine_array_event array,
    int newSize,
    spine_event defaultValue,
  ) {
    return _spine_array_event_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_event_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_event Function(spine_array_event, ffi.Size, spine_event)>>(
          'spine_array_event_set_size');
  late final _spine_array_event_set_size =
      _spine_array_event_set_sizePtr.asFunction<spine_array_event Function(spine_array_event, int, spine_event)>();

  void spine_array_event_ensure_capacity(
    spine_array_event array,
    int newCapacity,
  ) {
    return _spine_array_event_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_event_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event, ffi.Size)>>('spine_array_event_ensure_capacity');
  late final _spine_array_event_ensure_capacity =
      _spine_array_event_ensure_capacityPtr.asFunction<void Function(spine_array_event, int)>();

  void spine_array_event_add(
    spine_array_event array,
    spine_event inValue,
  ) {
    return _spine_array_event_add(
      array,
      inValue,
    );
  }

  late final _spine_array_event_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event, spine_event)>>('spine_array_event_add');
  late final _spine_array_event_add =
      _spine_array_event_addPtr.asFunction<void Function(spine_array_event, spine_event)>();

  void spine_array_event_add_all(
    spine_array_event array,
    spine_array_event inValue,
  ) {
    return _spine_array_event_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_event_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event, spine_array_event)>>('spine_array_event_add_all');
  late final _spine_array_event_add_all =
      _spine_array_event_add_allPtr.asFunction<void Function(spine_array_event, spine_array_event)>();

  void spine_array_event_clear_and_add_all(
    spine_array_event array,
    spine_array_event inValue,
  ) {
    return _spine_array_event_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_event_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event, spine_array_event)>>(
          'spine_array_event_clear_and_add_all');
  late final _spine_array_event_clear_and_add_all =
      _spine_array_event_clear_and_add_allPtr.asFunction<void Function(spine_array_event, spine_array_event)>();

  void spine_array_event_remove_at(
    spine_array_event array,
    int inIndex,
  ) {
    return _spine_array_event_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_event_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event, ffi.Size)>>('spine_array_event_remove_at');
  late final _spine_array_event_remove_at =
      _spine_array_event_remove_atPtr.asFunction<void Function(spine_array_event, int)>();

  bool spine_array_event_contains(
    spine_array_event array,
    spine_event inValue,
  ) {
    return _spine_array_event_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_event_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_event, spine_event)>>('spine_array_event_contains');
  late final _spine_array_event_contains =
      _spine_array_event_containsPtr.asFunction<bool Function(spine_array_event, spine_event)>();

  int spine_array_event_index_of(
    spine_array_event array,
    spine_event inValue,
  ) {
    return _spine_array_event_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_event_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_event, spine_event)>>('spine_array_event_index_of');
  late final _spine_array_event_index_of =
      _spine_array_event_index_ofPtr.asFunction<int Function(spine_array_event, spine_event)>();

  ffi.Pointer<spine_event> spine_array_event_buffer(
    spine_array_event array,
  ) {
    return _spine_array_event_buffer(
      array,
    );
  }

  late final _spine_array_event_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_event> Function(spine_array_event)>>('spine_array_event_buffer');
  late final _spine_array_event_buffer =
      _spine_array_event_bufferPtr.asFunction<ffi.Pointer<spine_event> Function(spine_array_event)>();

  spine_array_event_data spine_array_event_data_create() {
    return _spine_array_event_data_create();
  }

  late final _spine_array_event_data_createPtr =
      _lookup<ffi.NativeFunction<spine_array_event_data Function()>>('spine_array_event_data_create');
  late final _spine_array_event_data_create =
      _spine_array_event_data_createPtr.asFunction<spine_array_event_data Function()>();

  spine_array_event_data spine_array_event_data_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_event_data_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_event_data_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_event_data Function(ffi.Size)>>(
          'spine_array_event_data_create_with_capacity');
  late final _spine_array_event_data_create_with_capacity =
      _spine_array_event_data_create_with_capacityPtr.asFunction<spine_array_event_data Function(int)>();

  void spine_array_event_data_dispose(
    spine_array_event_data array,
  ) {
    return _spine_array_event_data_dispose(
      array,
    );
  }

  late final _spine_array_event_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event_data)>>('spine_array_event_data_dispose');
  late final _spine_array_event_data_dispose =
      _spine_array_event_data_disposePtr.asFunction<void Function(spine_array_event_data)>();

  void spine_array_event_data_clear(
    spine_array_event_data array,
  ) {
    return _spine_array_event_data_clear(
      array,
    );
  }

  late final _spine_array_event_data_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event_data)>>('spine_array_event_data_clear');
  late final _spine_array_event_data_clear =
      _spine_array_event_data_clearPtr.asFunction<void Function(spine_array_event_data)>();

  int spine_array_event_data_get_capacity(
    spine_array_event_data array,
  ) {
    return _spine_array_event_data_get_capacity(
      array,
    );
  }

  late final _spine_array_event_data_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_event_data)>>('spine_array_event_data_get_capacity');
  late final _spine_array_event_data_get_capacity =
      _spine_array_event_data_get_capacityPtr.asFunction<int Function(spine_array_event_data)>();

  int spine_array_event_data_size(
    spine_array_event_data array,
  ) {
    return _spine_array_event_data_size(
      array,
    );
  }

  late final _spine_array_event_data_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_event_data)>>('spine_array_event_data_size');
  late final _spine_array_event_data_size =
      _spine_array_event_data_sizePtr.asFunction<int Function(spine_array_event_data)>();

  spine_array_event_data spine_array_event_data_set_size(
    spine_array_event_data array,
    int newSize,
    spine_event_data defaultValue,
  ) {
    return _spine_array_event_data_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_event_data_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_event_data Function(spine_array_event_data, ffi.Size, spine_event_data)>>(
          'spine_array_event_data_set_size');
  late final _spine_array_event_data_set_size = _spine_array_event_data_set_sizePtr
      .asFunction<spine_array_event_data Function(spine_array_event_data, int, spine_event_data)>();

  void spine_array_event_data_ensure_capacity(
    spine_array_event_data array,
    int newCapacity,
  ) {
    return _spine_array_event_data_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_event_data_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event_data, ffi.Size)>>(
          'spine_array_event_data_ensure_capacity');
  late final _spine_array_event_data_ensure_capacity =
      _spine_array_event_data_ensure_capacityPtr.asFunction<void Function(spine_array_event_data, int)>();

  void spine_array_event_data_add(
    spine_array_event_data array,
    spine_event_data inValue,
  ) {
    return _spine_array_event_data_add(
      array,
      inValue,
    );
  }

  late final _spine_array_event_data_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event_data, spine_event_data)>>(
          'spine_array_event_data_add');
  late final _spine_array_event_data_add =
      _spine_array_event_data_addPtr.asFunction<void Function(spine_array_event_data, spine_event_data)>();

  void spine_array_event_data_add_all(
    spine_array_event_data array,
    spine_array_event_data inValue,
  ) {
    return _spine_array_event_data_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_event_data_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event_data, spine_array_event_data)>>(
          'spine_array_event_data_add_all');
  late final _spine_array_event_data_add_all =
      _spine_array_event_data_add_allPtr.asFunction<void Function(spine_array_event_data, spine_array_event_data)>();

  void spine_array_event_data_clear_and_add_all(
    spine_array_event_data array,
    spine_array_event_data inValue,
  ) {
    return _spine_array_event_data_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_event_data_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event_data, spine_array_event_data)>>(
          'spine_array_event_data_clear_and_add_all');
  late final _spine_array_event_data_clear_and_add_all = _spine_array_event_data_clear_and_add_allPtr
      .asFunction<void Function(spine_array_event_data, spine_array_event_data)>();

  void spine_array_event_data_remove_at(
    spine_array_event_data array,
    int inIndex,
  ) {
    return _spine_array_event_data_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_event_data_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_event_data, ffi.Size)>>(
          'spine_array_event_data_remove_at');
  late final _spine_array_event_data_remove_at =
      _spine_array_event_data_remove_atPtr.asFunction<void Function(spine_array_event_data, int)>();

  bool spine_array_event_data_contains(
    spine_array_event_data array,
    spine_event_data inValue,
  ) {
    return _spine_array_event_data_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_event_data_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_event_data, spine_event_data)>>(
          'spine_array_event_data_contains');
  late final _spine_array_event_data_contains =
      _spine_array_event_data_containsPtr.asFunction<bool Function(spine_array_event_data, spine_event_data)>();

  int spine_array_event_data_index_of(
    spine_array_event_data array,
    spine_event_data inValue,
  ) {
    return _spine_array_event_data_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_event_data_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_event_data, spine_event_data)>>(
          'spine_array_event_data_index_of');
  late final _spine_array_event_data_index_of =
      _spine_array_event_data_index_ofPtr.asFunction<int Function(spine_array_event_data, spine_event_data)>();

  ffi.Pointer<spine_event_data> spine_array_event_data_buffer(
    spine_array_event_data array,
  ) {
    return _spine_array_event_data_buffer(
      array,
    );
  }

  late final _spine_array_event_data_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_event_data> Function(spine_array_event_data)>>(
          'spine_array_event_data_buffer');
  late final _spine_array_event_data_buffer =
      _spine_array_event_data_bufferPtr.asFunction<ffi.Pointer<spine_event_data> Function(spine_array_event_data)>();

  spine_array_from_property spine_array_from_property_create() {
    return _spine_array_from_property_create();
  }

  late final _spine_array_from_property_createPtr =
      _lookup<ffi.NativeFunction<spine_array_from_property Function()>>('spine_array_from_property_create');
  late final _spine_array_from_property_create =
      _spine_array_from_property_createPtr.asFunction<spine_array_from_property Function()>();

  spine_array_from_property spine_array_from_property_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_from_property_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_from_property_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_from_property Function(ffi.Size)>>(
          'spine_array_from_property_create_with_capacity');
  late final _spine_array_from_property_create_with_capacity =
      _spine_array_from_property_create_with_capacityPtr.asFunction<spine_array_from_property Function(int)>();

  void spine_array_from_property_dispose(
    spine_array_from_property array,
  ) {
    return _spine_array_from_property_dispose(
      array,
    );
  }

  late final _spine_array_from_property_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_from_property)>>('spine_array_from_property_dispose');
  late final _spine_array_from_property_dispose =
      _spine_array_from_property_disposePtr.asFunction<void Function(spine_array_from_property)>();

  void spine_array_from_property_clear(
    spine_array_from_property array,
  ) {
    return _spine_array_from_property_clear(
      array,
    );
  }

  late final _spine_array_from_property_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_from_property)>>('spine_array_from_property_clear');
  late final _spine_array_from_property_clear =
      _spine_array_from_property_clearPtr.asFunction<void Function(spine_array_from_property)>();

  int spine_array_from_property_get_capacity(
    spine_array_from_property array,
  ) {
    return _spine_array_from_property_get_capacity(
      array,
    );
  }

  late final _spine_array_from_property_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_from_property)>>(
          'spine_array_from_property_get_capacity');
  late final _spine_array_from_property_get_capacity =
      _spine_array_from_property_get_capacityPtr.asFunction<int Function(spine_array_from_property)>();

  int spine_array_from_property_size(
    spine_array_from_property array,
  ) {
    return _spine_array_from_property_size(
      array,
    );
  }

  late final _spine_array_from_property_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_from_property)>>('spine_array_from_property_size');
  late final _spine_array_from_property_size =
      _spine_array_from_property_sizePtr.asFunction<int Function(spine_array_from_property)>();

  spine_array_from_property spine_array_from_property_set_size(
    spine_array_from_property array,
    int newSize,
    spine_from_property defaultValue,
  ) {
    return _spine_array_from_property_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_from_property_set_sizePtr = _lookup<
      ffi.NativeFunction<
          spine_array_from_property Function(
              spine_array_from_property, ffi.Size, spine_from_property)>>('spine_array_from_property_set_size');
  late final _spine_array_from_property_set_size = _spine_array_from_property_set_sizePtr
      .asFunction<spine_array_from_property Function(spine_array_from_property, int, spine_from_property)>();

  void spine_array_from_property_ensure_capacity(
    spine_array_from_property array,
    int newCapacity,
  ) {
    return _spine_array_from_property_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_from_property_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_from_property, ffi.Size)>>(
          'spine_array_from_property_ensure_capacity');
  late final _spine_array_from_property_ensure_capacity =
      _spine_array_from_property_ensure_capacityPtr.asFunction<void Function(spine_array_from_property, int)>();

  void spine_array_from_property_add(
    spine_array_from_property array,
    spine_from_property inValue,
  ) {
    return _spine_array_from_property_add(
      array,
      inValue,
    );
  }

  late final _spine_array_from_property_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_from_property, spine_from_property)>>(
          'spine_array_from_property_add');
  late final _spine_array_from_property_add =
      _spine_array_from_property_addPtr.asFunction<void Function(spine_array_from_property, spine_from_property)>();

  void spine_array_from_property_add_all(
    spine_array_from_property array,
    spine_array_from_property inValue,
  ) {
    return _spine_array_from_property_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_from_property_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_from_property, spine_array_from_property)>>(
          'spine_array_from_property_add_all');
  late final _spine_array_from_property_add_all = _spine_array_from_property_add_allPtr
      .asFunction<void Function(spine_array_from_property, spine_array_from_property)>();

  void spine_array_from_property_clear_and_add_all(
    spine_array_from_property array,
    spine_array_from_property inValue,
  ) {
    return _spine_array_from_property_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_from_property_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_from_property, spine_array_from_property)>>(
          'spine_array_from_property_clear_and_add_all');
  late final _spine_array_from_property_clear_and_add_all = _spine_array_from_property_clear_and_add_allPtr
      .asFunction<void Function(spine_array_from_property, spine_array_from_property)>();

  void spine_array_from_property_remove_at(
    spine_array_from_property array,
    int inIndex,
  ) {
    return _spine_array_from_property_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_from_property_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_from_property, ffi.Size)>>(
          'spine_array_from_property_remove_at');
  late final _spine_array_from_property_remove_at =
      _spine_array_from_property_remove_atPtr.asFunction<void Function(spine_array_from_property, int)>();

  bool spine_array_from_property_contains(
    spine_array_from_property array,
    spine_from_property inValue,
  ) {
    return _spine_array_from_property_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_from_property_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_from_property, spine_from_property)>>(
          'spine_array_from_property_contains');
  late final _spine_array_from_property_contains = _spine_array_from_property_containsPtr
      .asFunction<bool Function(spine_array_from_property, spine_from_property)>();

  int spine_array_from_property_index_of(
    spine_array_from_property array,
    spine_from_property inValue,
  ) {
    return _spine_array_from_property_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_from_property_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_from_property, spine_from_property)>>(
          'spine_array_from_property_index_of');
  late final _spine_array_from_property_index_of =
      _spine_array_from_property_index_ofPtr.asFunction<int Function(spine_array_from_property, spine_from_property)>();

  ffi.Pointer<spine_from_property> spine_array_from_property_buffer(
    spine_array_from_property array,
  ) {
    return _spine_array_from_property_buffer(
      array,
    );
  }

  late final _spine_array_from_property_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_from_property> Function(spine_array_from_property)>>(
          'spine_array_from_property_buffer');
  late final _spine_array_from_property_buffer = _spine_array_from_property_bufferPtr
      .asFunction<ffi.Pointer<spine_from_property> Function(spine_array_from_property)>();

  spine_array_physics_constraint spine_array_physics_constraint_create() {
    return _spine_array_physics_constraint_create();
  }

  late final _spine_array_physics_constraint_createPtr =
      _lookup<ffi.NativeFunction<spine_array_physics_constraint Function()>>('spine_array_physics_constraint_create');
  late final _spine_array_physics_constraint_create =
      _spine_array_physics_constraint_createPtr.asFunction<spine_array_physics_constraint Function()>();

  spine_array_physics_constraint spine_array_physics_constraint_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_physics_constraint_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_physics_constraint_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_physics_constraint Function(ffi.Size)>>(
          'spine_array_physics_constraint_create_with_capacity');
  late final _spine_array_physics_constraint_create_with_capacity =
      _spine_array_physics_constraint_create_with_capacityPtr
          .asFunction<spine_array_physics_constraint Function(int)>();

  void spine_array_physics_constraint_dispose(
    spine_array_physics_constraint array,
  ) {
    return _spine_array_physics_constraint_dispose(
      array,
    );
  }

  late final _spine_array_physics_constraint_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_physics_constraint)>>(
          'spine_array_physics_constraint_dispose');
  late final _spine_array_physics_constraint_dispose =
      _spine_array_physics_constraint_disposePtr.asFunction<void Function(spine_array_physics_constraint)>();

  void spine_array_physics_constraint_clear(
    spine_array_physics_constraint array,
  ) {
    return _spine_array_physics_constraint_clear(
      array,
    );
  }

  late final _spine_array_physics_constraint_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_physics_constraint)>>(
          'spine_array_physics_constraint_clear');
  late final _spine_array_physics_constraint_clear =
      _spine_array_physics_constraint_clearPtr.asFunction<void Function(spine_array_physics_constraint)>();

  int spine_array_physics_constraint_get_capacity(
    spine_array_physics_constraint array,
  ) {
    return _spine_array_physics_constraint_get_capacity(
      array,
    );
  }

  late final _spine_array_physics_constraint_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_physics_constraint)>>(
          'spine_array_physics_constraint_get_capacity');
  late final _spine_array_physics_constraint_get_capacity =
      _spine_array_physics_constraint_get_capacityPtr.asFunction<int Function(spine_array_physics_constraint)>();

  int spine_array_physics_constraint_size(
    spine_array_physics_constraint array,
  ) {
    return _spine_array_physics_constraint_size(
      array,
    );
  }

  late final _spine_array_physics_constraint_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_physics_constraint)>>(
          'spine_array_physics_constraint_size');
  late final _spine_array_physics_constraint_size =
      _spine_array_physics_constraint_sizePtr.asFunction<int Function(spine_array_physics_constraint)>();

  spine_array_physics_constraint spine_array_physics_constraint_set_size(
    spine_array_physics_constraint array,
    int newSize,
    spine_physics_constraint defaultValue,
  ) {
    return _spine_array_physics_constraint_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_physics_constraint_set_sizePtr = _lookup<
      ffi.NativeFunction<
          spine_array_physics_constraint Function(spine_array_physics_constraint, ffi.Size,
              spine_physics_constraint)>>('spine_array_physics_constraint_set_size');
  late final _spine_array_physics_constraint_set_size = _spine_array_physics_constraint_set_sizePtr.asFunction<
      spine_array_physics_constraint Function(spine_array_physics_constraint, int, spine_physics_constraint)>();

  void spine_array_physics_constraint_ensure_capacity(
    spine_array_physics_constraint array,
    int newCapacity,
  ) {
    return _spine_array_physics_constraint_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_physics_constraint_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_physics_constraint, ffi.Size)>>(
          'spine_array_physics_constraint_ensure_capacity');
  late final _spine_array_physics_constraint_ensure_capacity = _spine_array_physics_constraint_ensure_capacityPtr
      .asFunction<void Function(spine_array_physics_constraint, int)>();

  void spine_array_physics_constraint_add(
    spine_array_physics_constraint array,
    spine_physics_constraint inValue,
  ) {
    return _spine_array_physics_constraint_add(
      array,
      inValue,
    );
  }

  late final _spine_array_physics_constraint_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_physics_constraint, spine_physics_constraint)>>(
          'spine_array_physics_constraint_add');
  late final _spine_array_physics_constraint_add = _spine_array_physics_constraint_addPtr
      .asFunction<void Function(spine_array_physics_constraint, spine_physics_constraint)>();

  void spine_array_physics_constraint_add_all(
    spine_array_physics_constraint array,
    spine_array_physics_constraint inValue,
  ) {
    return _spine_array_physics_constraint_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_physics_constraint_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_physics_constraint, spine_array_physics_constraint)>>(
          'spine_array_physics_constraint_add_all');
  late final _spine_array_physics_constraint_add_all = _spine_array_physics_constraint_add_allPtr
      .asFunction<void Function(spine_array_physics_constraint, spine_array_physics_constraint)>();

  void spine_array_physics_constraint_clear_and_add_all(
    spine_array_physics_constraint array,
    spine_array_physics_constraint inValue,
  ) {
    return _spine_array_physics_constraint_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_physics_constraint_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_physics_constraint, spine_array_physics_constraint)>>(
          'spine_array_physics_constraint_clear_and_add_all');
  late final _spine_array_physics_constraint_clear_and_add_all = _spine_array_physics_constraint_clear_and_add_allPtr
      .asFunction<void Function(spine_array_physics_constraint, spine_array_physics_constraint)>();

  void spine_array_physics_constraint_remove_at(
    spine_array_physics_constraint array,
    int inIndex,
  ) {
    return _spine_array_physics_constraint_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_physics_constraint_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_physics_constraint, ffi.Size)>>(
          'spine_array_physics_constraint_remove_at');
  late final _spine_array_physics_constraint_remove_at =
      _spine_array_physics_constraint_remove_atPtr.asFunction<void Function(spine_array_physics_constraint, int)>();

  bool spine_array_physics_constraint_contains(
    spine_array_physics_constraint array,
    spine_physics_constraint inValue,
  ) {
    return _spine_array_physics_constraint_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_physics_constraint_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_physics_constraint, spine_physics_constraint)>>(
          'spine_array_physics_constraint_contains');
  late final _spine_array_physics_constraint_contains = _spine_array_physics_constraint_containsPtr
      .asFunction<bool Function(spine_array_physics_constraint, spine_physics_constraint)>();

  int spine_array_physics_constraint_index_of(
    spine_array_physics_constraint array,
    spine_physics_constraint inValue,
  ) {
    return _spine_array_physics_constraint_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_physics_constraint_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_physics_constraint, spine_physics_constraint)>>(
          'spine_array_physics_constraint_index_of');
  late final _spine_array_physics_constraint_index_of = _spine_array_physics_constraint_index_ofPtr
      .asFunction<int Function(spine_array_physics_constraint, spine_physics_constraint)>();

  ffi.Pointer<spine_physics_constraint> spine_array_physics_constraint_buffer(
    spine_array_physics_constraint array,
  ) {
    return _spine_array_physics_constraint_buffer(
      array,
    );
  }

  late final _spine_array_physics_constraint_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_physics_constraint> Function(spine_array_physics_constraint)>>(
          'spine_array_physics_constraint_buffer');
  late final _spine_array_physics_constraint_buffer = _spine_array_physics_constraint_bufferPtr
      .asFunction<ffi.Pointer<spine_physics_constraint> Function(spine_array_physics_constraint)>();

  spine_array_polygon spine_array_polygon_create() {
    return _spine_array_polygon_create();
  }

  late final _spine_array_polygon_createPtr =
      _lookup<ffi.NativeFunction<spine_array_polygon Function()>>('spine_array_polygon_create');
  late final _spine_array_polygon_create = _spine_array_polygon_createPtr.asFunction<spine_array_polygon Function()>();

  spine_array_polygon spine_array_polygon_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_polygon_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_polygon_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_polygon Function(ffi.Size)>>('spine_array_polygon_create_with_capacity');
  late final _spine_array_polygon_create_with_capacity =
      _spine_array_polygon_create_with_capacityPtr.asFunction<spine_array_polygon Function(int)>();

  void spine_array_polygon_dispose(
    spine_array_polygon array,
  ) {
    return _spine_array_polygon_dispose(
      array,
    );
  }

  late final _spine_array_polygon_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_polygon)>>('spine_array_polygon_dispose');
  late final _spine_array_polygon_dispose =
      _spine_array_polygon_disposePtr.asFunction<void Function(spine_array_polygon)>();

  void spine_array_polygon_clear(
    spine_array_polygon array,
  ) {
    return _spine_array_polygon_clear(
      array,
    );
  }

  late final _spine_array_polygon_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_polygon)>>('spine_array_polygon_clear');
  late final _spine_array_polygon_clear =
      _spine_array_polygon_clearPtr.asFunction<void Function(spine_array_polygon)>();

  int spine_array_polygon_get_capacity(
    spine_array_polygon array,
  ) {
    return _spine_array_polygon_get_capacity(
      array,
    );
  }

  late final _spine_array_polygon_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_polygon)>>('spine_array_polygon_get_capacity');
  late final _spine_array_polygon_get_capacity =
      _spine_array_polygon_get_capacityPtr.asFunction<int Function(spine_array_polygon)>();

  int spine_array_polygon_size(
    spine_array_polygon array,
  ) {
    return _spine_array_polygon_size(
      array,
    );
  }

  late final _spine_array_polygon_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_polygon)>>('spine_array_polygon_size');
  late final _spine_array_polygon_size = _spine_array_polygon_sizePtr.asFunction<int Function(spine_array_polygon)>();

  spine_array_polygon spine_array_polygon_set_size(
    spine_array_polygon array,
    int newSize,
    spine_polygon defaultValue,
  ) {
    return _spine_array_polygon_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_polygon_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_polygon Function(spine_array_polygon, ffi.Size, spine_polygon)>>(
          'spine_array_polygon_set_size');
  late final _spine_array_polygon_set_size = _spine_array_polygon_set_sizePtr
      .asFunction<spine_array_polygon Function(spine_array_polygon, int, spine_polygon)>();

  void spine_array_polygon_ensure_capacity(
    spine_array_polygon array,
    int newCapacity,
  ) {
    return _spine_array_polygon_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_polygon_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_polygon, ffi.Size)>>(
          'spine_array_polygon_ensure_capacity');
  late final _spine_array_polygon_ensure_capacity =
      _spine_array_polygon_ensure_capacityPtr.asFunction<void Function(spine_array_polygon, int)>();

  void spine_array_polygon_add(
    spine_array_polygon array,
    spine_polygon inValue,
  ) {
    return _spine_array_polygon_add(
      array,
      inValue,
    );
  }

  late final _spine_array_polygon_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_polygon, spine_polygon)>>('spine_array_polygon_add');
  late final _spine_array_polygon_add =
      _spine_array_polygon_addPtr.asFunction<void Function(spine_array_polygon, spine_polygon)>();

  void spine_array_polygon_add_all(
    spine_array_polygon array,
    spine_array_polygon inValue,
  ) {
    return _spine_array_polygon_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_polygon_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_polygon, spine_array_polygon)>>(
          'spine_array_polygon_add_all');
  late final _spine_array_polygon_add_all =
      _spine_array_polygon_add_allPtr.asFunction<void Function(spine_array_polygon, spine_array_polygon)>();

  void spine_array_polygon_clear_and_add_all(
    spine_array_polygon array,
    spine_array_polygon inValue,
  ) {
    return _spine_array_polygon_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_polygon_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_polygon, spine_array_polygon)>>(
          'spine_array_polygon_clear_and_add_all');
  late final _spine_array_polygon_clear_and_add_all =
      _spine_array_polygon_clear_and_add_allPtr.asFunction<void Function(spine_array_polygon, spine_array_polygon)>();

  void spine_array_polygon_remove_at(
    spine_array_polygon array,
    int inIndex,
  ) {
    return _spine_array_polygon_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_polygon_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_polygon, ffi.Size)>>('spine_array_polygon_remove_at');
  late final _spine_array_polygon_remove_at =
      _spine_array_polygon_remove_atPtr.asFunction<void Function(spine_array_polygon, int)>();

  bool spine_array_polygon_contains(
    spine_array_polygon array,
    spine_polygon inValue,
  ) {
    return _spine_array_polygon_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_polygon_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_polygon, spine_polygon)>>(
          'spine_array_polygon_contains');
  late final _spine_array_polygon_contains =
      _spine_array_polygon_containsPtr.asFunction<bool Function(spine_array_polygon, spine_polygon)>();

  int spine_array_polygon_index_of(
    spine_array_polygon array,
    spine_polygon inValue,
  ) {
    return _spine_array_polygon_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_polygon_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_polygon, spine_polygon)>>('spine_array_polygon_index_of');
  late final _spine_array_polygon_index_of =
      _spine_array_polygon_index_ofPtr.asFunction<int Function(spine_array_polygon, spine_polygon)>();

  ffi.Pointer<spine_polygon> spine_array_polygon_buffer(
    spine_array_polygon array,
  ) {
    return _spine_array_polygon_buffer(
      array,
    );
  }

  late final _spine_array_polygon_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_polygon> Function(spine_array_polygon)>>(
          'spine_array_polygon_buffer');
  late final _spine_array_polygon_buffer =
      _spine_array_polygon_bufferPtr.asFunction<ffi.Pointer<spine_polygon> Function(spine_array_polygon)>();

  spine_array_skin spine_array_skin_create() {
    return _spine_array_skin_create();
  }

  late final _spine_array_skin_createPtr =
      _lookup<ffi.NativeFunction<spine_array_skin Function()>>('spine_array_skin_create');
  late final _spine_array_skin_create = _spine_array_skin_createPtr.asFunction<spine_array_skin Function()>();

  spine_array_skin spine_array_skin_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_skin_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_skin_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_skin Function(ffi.Size)>>('spine_array_skin_create_with_capacity');
  late final _spine_array_skin_create_with_capacity =
      _spine_array_skin_create_with_capacityPtr.asFunction<spine_array_skin Function(int)>();

  void spine_array_skin_dispose(
    spine_array_skin array,
  ) {
    return _spine_array_skin_dispose(
      array,
    );
  }

  late final _spine_array_skin_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_skin)>>('spine_array_skin_dispose');
  late final _spine_array_skin_dispose = _spine_array_skin_disposePtr.asFunction<void Function(spine_array_skin)>();

  void spine_array_skin_clear(
    spine_array_skin array,
  ) {
    return _spine_array_skin_clear(
      array,
    );
  }

  late final _spine_array_skin_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_skin)>>('spine_array_skin_clear');
  late final _spine_array_skin_clear = _spine_array_skin_clearPtr.asFunction<void Function(spine_array_skin)>();

  int spine_array_skin_get_capacity(
    spine_array_skin array,
  ) {
    return _spine_array_skin_get_capacity(
      array,
    );
  }

  late final _spine_array_skin_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_skin)>>('spine_array_skin_get_capacity');
  late final _spine_array_skin_get_capacity =
      _spine_array_skin_get_capacityPtr.asFunction<int Function(spine_array_skin)>();

  int spine_array_skin_size(
    spine_array_skin array,
  ) {
    return _spine_array_skin_size(
      array,
    );
  }

  late final _spine_array_skin_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_skin)>>('spine_array_skin_size');
  late final _spine_array_skin_size = _spine_array_skin_sizePtr.asFunction<int Function(spine_array_skin)>();

  spine_array_skin spine_array_skin_set_size(
    spine_array_skin array,
    int newSize,
    spine_skin defaultValue,
  ) {
    return _spine_array_skin_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_skin_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_skin Function(spine_array_skin, ffi.Size, spine_skin)>>(
          'spine_array_skin_set_size');
  late final _spine_array_skin_set_size =
      _spine_array_skin_set_sizePtr.asFunction<spine_array_skin Function(spine_array_skin, int, spine_skin)>();

  void spine_array_skin_ensure_capacity(
    spine_array_skin array,
    int newCapacity,
  ) {
    return _spine_array_skin_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_skin_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_skin, ffi.Size)>>('spine_array_skin_ensure_capacity');
  late final _spine_array_skin_ensure_capacity =
      _spine_array_skin_ensure_capacityPtr.asFunction<void Function(spine_array_skin, int)>();

  void spine_array_skin_add(
    spine_array_skin array,
    spine_skin inValue,
  ) {
    return _spine_array_skin_add(
      array,
      inValue,
    );
  }

  late final _spine_array_skin_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_skin, spine_skin)>>('spine_array_skin_add');
  late final _spine_array_skin_add = _spine_array_skin_addPtr.asFunction<void Function(spine_array_skin, spine_skin)>();

  void spine_array_skin_add_all(
    spine_array_skin array,
    spine_array_skin inValue,
  ) {
    return _spine_array_skin_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_skin_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_skin, spine_array_skin)>>('spine_array_skin_add_all');
  late final _spine_array_skin_add_all =
      _spine_array_skin_add_allPtr.asFunction<void Function(spine_array_skin, spine_array_skin)>();

  void spine_array_skin_clear_and_add_all(
    spine_array_skin array,
    spine_array_skin inValue,
  ) {
    return _spine_array_skin_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_skin_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_skin, spine_array_skin)>>(
          'spine_array_skin_clear_and_add_all');
  late final _spine_array_skin_clear_and_add_all =
      _spine_array_skin_clear_and_add_allPtr.asFunction<void Function(spine_array_skin, spine_array_skin)>();

  void spine_array_skin_remove_at(
    spine_array_skin array,
    int inIndex,
  ) {
    return _spine_array_skin_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_skin_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_skin, ffi.Size)>>('spine_array_skin_remove_at');
  late final _spine_array_skin_remove_at =
      _spine_array_skin_remove_atPtr.asFunction<void Function(spine_array_skin, int)>();

  bool spine_array_skin_contains(
    spine_array_skin array,
    spine_skin inValue,
  ) {
    return _spine_array_skin_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_skin_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_skin, spine_skin)>>('spine_array_skin_contains');
  late final _spine_array_skin_contains =
      _spine_array_skin_containsPtr.asFunction<bool Function(spine_array_skin, spine_skin)>();

  int spine_array_skin_index_of(
    spine_array_skin array,
    spine_skin inValue,
  ) {
    return _spine_array_skin_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_skin_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_skin, spine_skin)>>('spine_array_skin_index_of');
  late final _spine_array_skin_index_of =
      _spine_array_skin_index_ofPtr.asFunction<int Function(spine_array_skin, spine_skin)>();

  ffi.Pointer<spine_skin> spine_array_skin_buffer(
    spine_array_skin array,
  ) {
    return _spine_array_skin_buffer(
      array,
    );
  }

  late final _spine_array_skin_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_skin> Function(spine_array_skin)>>('spine_array_skin_buffer');
  late final _spine_array_skin_buffer =
      _spine_array_skin_bufferPtr.asFunction<ffi.Pointer<spine_skin> Function(spine_array_skin)>();

  spine_array_slot spine_array_slot_create() {
    return _spine_array_slot_create();
  }

  late final _spine_array_slot_createPtr =
      _lookup<ffi.NativeFunction<spine_array_slot Function()>>('spine_array_slot_create');
  late final _spine_array_slot_create = _spine_array_slot_createPtr.asFunction<spine_array_slot Function()>();

  spine_array_slot spine_array_slot_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_slot_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_slot_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_slot Function(ffi.Size)>>('spine_array_slot_create_with_capacity');
  late final _spine_array_slot_create_with_capacity =
      _spine_array_slot_create_with_capacityPtr.asFunction<spine_array_slot Function(int)>();

  void spine_array_slot_dispose(
    spine_array_slot array,
  ) {
    return _spine_array_slot_dispose(
      array,
    );
  }

  late final _spine_array_slot_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot)>>('spine_array_slot_dispose');
  late final _spine_array_slot_dispose = _spine_array_slot_disposePtr.asFunction<void Function(spine_array_slot)>();

  void spine_array_slot_clear(
    spine_array_slot array,
  ) {
    return _spine_array_slot_clear(
      array,
    );
  }

  late final _spine_array_slot_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot)>>('spine_array_slot_clear');
  late final _spine_array_slot_clear = _spine_array_slot_clearPtr.asFunction<void Function(spine_array_slot)>();

  int spine_array_slot_get_capacity(
    spine_array_slot array,
  ) {
    return _spine_array_slot_get_capacity(
      array,
    );
  }

  late final _spine_array_slot_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_slot)>>('spine_array_slot_get_capacity');
  late final _spine_array_slot_get_capacity =
      _spine_array_slot_get_capacityPtr.asFunction<int Function(spine_array_slot)>();

  int spine_array_slot_size(
    spine_array_slot array,
  ) {
    return _spine_array_slot_size(
      array,
    );
  }

  late final _spine_array_slot_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_slot)>>('spine_array_slot_size');
  late final _spine_array_slot_size = _spine_array_slot_sizePtr.asFunction<int Function(spine_array_slot)>();

  spine_array_slot spine_array_slot_set_size(
    spine_array_slot array,
    int newSize,
    spine_slot defaultValue,
  ) {
    return _spine_array_slot_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_slot_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_slot Function(spine_array_slot, ffi.Size, spine_slot)>>(
          'spine_array_slot_set_size');
  late final _spine_array_slot_set_size =
      _spine_array_slot_set_sizePtr.asFunction<spine_array_slot Function(spine_array_slot, int, spine_slot)>();

  void spine_array_slot_ensure_capacity(
    spine_array_slot array,
    int newCapacity,
  ) {
    return _spine_array_slot_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_slot_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot, ffi.Size)>>('spine_array_slot_ensure_capacity');
  late final _spine_array_slot_ensure_capacity =
      _spine_array_slot_ensure_capacityPtr.asFunction<void Function(spine_array_slot, int)>();

  void spine_array_slot_add(
    spine_array_slot array,
    spine_slot inValue,
  ) {
    return _spine_array_slot_add(
      array,
      inValue,
    );
  }

  late final _spine_array_slot_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot, spine_slot)>>('spine_array_slot_add');
  late final _spine_array_slot_add = _spine_array_slot_addPtr.asFunction<void Function(spine_array_slot, spine_slot)>();

  void spine_array_slot_add_all(
    spine_array_slot array,
    spine_array_slot inValue,
  ) {
    return _spine_array_slot_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_slot_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot, spine_array_slot)>>('spine_array_slot_add_all');
  late final _spine_array_slot_add_all =
      _spine_array_slot_add_allPtr.asFunction<void Function(spine_array_slot, spine_array_slot)>();

  void spine_array_slot_clear_and_add_all(
    spine_array_slot array,
    spine_array_slot inValue,
  ) {
    return _spine_array_slot_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_slot_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot, spine_array_slot)>>(
          'spine_array_slot_clear_and_add_all');
  late final _spine_array_slot_clear_and_add_all =
      _spine_array_slot_clear_and_add_allPtr.asFunction<void Function(spine_array_slot, spine_array_slot)>();

  void spine_array_slot_remove_at(
    spine_array_slot array,
    int inIndex,
  ) {
    return _spine_array_slot_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_slot_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot, ffi.Size)>>('spine_array_slot_remove_at');
  late final _spine_array_slot_remove_at =
      _spine_array_slot_remove_atPtr.asFunction<void Function(spine_array_slot, int)>();

  bool spine_array_slot_contains(
    spine_array_slot array,
    spine_slot inValue,
  ) {
    return _spine_array_slot_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_slot_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_slot, spine_slot)>>('spine_array_slot_contains');
  late final _spine_array_slot_contains =
      _spine_array_slot_containsPtr.asFunction<bool Function(spine_array_slot, spine_slot)>();

  int spine_array_slot_index_of(
    spine_array_slot array,
    spine_slot inValue,
  ) {
    return _spine_array_slot_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_slot_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_slot, spine_slot)>>('spine_array_slot_index_of');
  late final _spine_array_slot_index_of =
      _spine_array_slot_index_ofPtr.asFunction<int Function(spine_array_slot, spine_slot)>();

  ffi.Pointer<spine_slot> spine_array_slot_buffer(
    spine_array_slot array,
  ) {
    return _spine_array_slot_buffer(
      array,
    );
  }

  late final _spine_array_slot_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_slot> Function(spine_array_slot)>>('spine_array_slot_buffer');
  late final _spine_array_slot_buffer =
      _spine_array_slot_bufferPtr.asFunction<ffi.Pointer<spine_slot> Function(spine_array_slot)>();

  spine_array_slot_data spine_array_slot_data_create() {
    return _spine_array_slot_data_create();
  }

  late final _spine_array_slot_data_createPtr =
      _lookup<ffi.NativeFunction<spine_array_slot_data Function()>>('spine_array_slot_data_create');
  late final _spine_array_slot_data_create =
      _spine_array_slot_data_createPtr.asFunction<spine_array_slot_data Function()>();

  spine_array_slot_data spine_array_slot_data_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_slot_data_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_slot_data_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_slot_data Function(ffi.Size)>>(
          'spine_array_slot_data_create_with_capacity');
  late final _spine_array_slot_data_create_with_capacity =
      _spine_array_slot_data_create_with_capacityPtr.asFunction<spine_array_slot_data Function(int)>();

  void spine_array_slot_data_dispose(
    spine_array_slot_data array,
  ) {
    return _spine_array_slot_data_dispose(
      array,
    );
  }

  late final _spine_array_slot_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot_data)>>('spine_array_slot_data_dispose');
  late final _spine_array_slot_data_dispose =
      _spine_array_slot_data_disposePtr.asFunction<void Function(spine_array_slot_data)>();

  void spine_array_slot_data_clear(
    spine_array_slot_data array,
  ) {
    return _spine_array_slot_data_clear(
      array,
    );
  }

  late final _spine_array_slot_data_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot_data)>>('spine_array_slot_data_clear');
  late final _spine_array_slot_data_clear =
      _spine_array_slot_data_clearPtr.asFunction<void Function(spine_array_slot_data)>();

  int spine_array_slot_data_get_capacity(
    spine_array_slot_data array,
  ) {
    return _spine_array_slot_data_get_capacity(
      array,
    );
  }

  late final _spine_array_slot_data_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_slot_data)>>('spine_array_slot_data_get_capacity');
  late final _spine_array_slot_data_get_capacity =
      _spine_array_slot_data_get_capacityPtr.asFunction<int Function(spine_array_slot_data)>();

  int spine_array_slot_data_size(
    spine_array_slot_data array,
  ) {
    return _spine_array_slot_data_size(
      array,
    );
  }

  late final _spine_array_slot_data_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_slot_data)>>('spine_array_slot_data_size');
  late final _spine_array_slot_data_size =
      _spine_array_slot_data_sizePtr.asFunction<int Function(spine_array_slot_data)>();

  spine_array_slot_data spine_array_slot_data_set_size(
    spine_array_slot_data array,
    int newSize,
    spine_slot_data defaultValue,
  ) {
    return _spine_array_slot_data_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_slot_data_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_slot_data Function(spine_array_slot_data, ffi.Size, spine_slot_data)>>(
          'spine_array_slot_data_set_size');
  late final _spine_array_slot_data_set_size = _spine_array_slot_data_set_sizePtr
      .asFunction<spine_array_slot_data Function(spine_array_slot_data, int, spine_slot_data)>();

  void spine_array_slot_data_ensure_capacity(
    spine_array_slot_data array,
    int newCapacity,
  ) {
    return _spine_array_slot_data_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_slot_data_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot_data, ffi.Size)>>(
          'spine_array_slot_data_ensure_capacity');
  late final _spine_array_slot_data_ensure_capacity =
      _spine_array_slot_data_ensure_capacityPtr.asFunction<void Function(spine_array_slot_data, int)>();

  void spine_array_slot_data_add(
    spine_array_slot_data array,
    spine_slot_data inValue,
  ) {
    return _spine_array_slot_data_add(
      array,
      inValue,
    );
  }

  late final _spine_array_slot_data_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot_data, spine_slot_data)>>(
          'spine_array_slot_data_add');
  late final _spine_array_slot_data_add =
      _spine_array_slot_data_addPtr.asFunction<void Function(spine_array_slot_data, spine_slot_data)>();

  void spine_array_slot_data_add_all(
    spine_array_slot_data array,
    spine_array_slot_data inValue,
  ) {
    return _spine_array_slot_data_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_slot_data_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot_data, spine_array_slot_data)>>(
          'spine_array_slot_data_add_all');
  late final _spine_array_slot_data_add_all =
      _spine_array_slot_data_add_allPtr.asFunction<void Function(spine_array_slot_data, spine_array_slot_data)>();

  void spine_array_slot_data_clear_and_add_all(
    spine_array_slot_data array,
    spine_array_slot_data inValue,
  ) {
    return _spine_array_slot_data_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_slot_data_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot_data, spine_array_slot_data)>>(
          'spine_array_slot_data_clear_and_add_all');
  late final _spine_array_slot_data_clear_and_add_all = _spine_array_slot_data_clear_and_add_allPtr
      .asFunction<void Function(spine_array_slot_data, spine_array_slot_data)>();

  void spine_array_slot_data_remove_at(
    spine_array_slot_data array,
    int inIndex,
  ) {
    return _spine_array_slot_data_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_slot_data_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_slot_data, ffi.Size)>>(
          'spine_array_slot_data_remove_at');
  late final _spine_array_slot_data_remove_at =
      _spine_array_slot_data_remove_atPtr.asFunction<void Function(spine_array_slot_data, int)>();

  bool spine_array_slot_data_contains(
    spine_array_slot_data array,
    spine_slot_data inValue,
  ) {
    return _spine_array_slot_data_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_slot_data_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_slot_data, spine_slot_data)>>(
          'spine_array_slot_data_contains');
  late final _spine_array_slot_data_contains =
      _spine_array_slot_data_containsPtr.asFunction<bool Function(spine_array_slot_data, spine_slot_data)>();

  int spine_array_slot_data_index_of(
    spine_array_slot_data array,
    spine_slot_data inValue,
  ) {
    return _spine_array_slot_data_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_slot_data_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_slot_data, spine_slot_data)>>(
          'spine_array_slot_data_index_of');
  late final _spine_array_slot_data_index_of =
      _spine_array_slot_data_index_ofPtr.asFunction<int Function(spine_array_slot_data, spine_slot_data)>();

  ffi.Pointer<spine_slot_data> spine_array_slot_data_buffer(
    spine_array_slot_data array,
  ) {
    return _spine_array_slot_data_buffer(
      array,
    );
  }

  late final _spine_array_slot_data_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_slot_data> Function(spine_array_slot_data)>>(
          'spine_array_slot_data_buffer');
  late final _spine_array_slot_data_buffer =
      _spine_array_slot_data_bufferPtr.asFunction<ffi.Pointer<spine_slot_data> Function(spine_array_slot_data)>();

  spine_array_texture_region spine_array_texture_region_create() {
    return _spine_array_texture_region_create();
  }

  late final _spine_array_texture_region_createPtr =
      _lookup<ffi.NativeFunction<spine_array_texture_region Function()>>('spine_array_texture_region_create');
  late final _spine_array_texture_region_create =
      _spine_array_texture_region_createPtr.asFunction<spine_array_texture_region Function()>();

  spine_array_texture_region spine_array_texture_region_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_texture_region_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_texture_region_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_texture_region Function(ffi.Size)>>(
          'spine_array_texture_region_create_with_capacity');
  late final _spine_array_texture_region_create_with_capacity =
      _spine_array_texture_region_create_with_capacityPtr.asFunction<spine_array_texture_region Function(int)>();

  void spine_array_texture_region_dispose(
    spine_array_texture_region array,
  ) {
    return _spine_array_texture_region_dispose(
      array,
    );
  }

  late final _spine_array_texture_region_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_texture_region)>>('spine_array_texture_region_dispose');
  late final _spine_array_texture_region_dispose =
      _spine_array_texture_region_disposePtr.asFunction<void Function(spine_array_texture_region)>();

  void spine_array_texture_region_clear(
    spine_array_texture_region array,
  ) {
    return _spine_array_texture_region_clear(
      array,
    );
  }

  late final _spine_array_texture_region_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_texture_region)>>('spine_array_texture_region_clear');
  late final _spine_array_texture_region_clear =
      _spine_array_texture_region_clearPtr.asFunction<void Function(spine_array_texture_region)>();

  int spine_array_texture_region_get_capacity(
    spine_array_texture_region array,
  ) {
    return _spine_array_texture_region_get_capacity(
      array,
    );
  }

  late final _spine_array_texture_region_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_texture_region)>>(
          'spine_array_texture_region_get_capacity');
  late final _spine_array_texture_region_get_capacity =
      _spine_array_texture_region_get_capacityPtr.asFunction<int Function(spine_array_texture_region)>();

  int spine_array_texture_region_size(
    spine_array_texture_region array,
  ) {
    return _spine_array_texture_region_size(
      array,
    );
  }

  late final _spine_array_texture_region_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_texture_region)>>('spine_array_texture_region_size');
  late final _spine_array_texture_region_size =
      _spine_array_texture_region_sizePtr.asFunction<int Function(spine_array_texture_region)>();

  spine_array_texture_region spine_array_texture_region_set_size(
    spine_array_texture_region array,
    int newSize,
    spine_texture_region defaultValue,
  ) {
    return _spine_array_texture_region_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_texture_region_set_sizePtr = _lookup<
      ffi.NativeFunction<
          spine_array_texture_region Function(
              spine_array_texture_region, ffi.Size, spine_texture_region)>>('spine_array_texture_region_set_size');
  late final _spine_array_texture_region_set_size = _spine_array_texture_region_set_sizePtr
      .asFunction<spine_array_texture_region Function(spine_array_texture_region, int, spine_texture_region)>();

  void spine_array_texture_region_ensure_capacity(
    spine_array_texture_region array,
    int newCapacity,
  ) {
    return _spine_array_texture_region_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_texture_region_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_texture_region, ffi.Size)>>(
          'spine_array_texture_region_ensure_capacity');
  late final _spine_array_texture_region_ensure_capacity =
      _spine_array_texture_region_ensure_capacityPtr.asFunction<void Function(spine_array_texture_region, int)>();

  void spine_array_texture_region_add(
    spine_array_texture_region array,
    spine_texture_region inValue,
  ) {
    return _spine_array_texture_region_add(
      array,
      inValue,
    );
  }

  late final _spine_array_texture_region_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_texture_region, spine_texture_region)>>(
          'spine_array_texture_region_add');
  late final _spine_array_texture_region_add =
      _spine_array_texture_region_addPtr.asFunction<void Function(spine_array_texture_region, spine_texture_region)>();

  void spine_array_texture_region_add_all(
    spine_array_texture_region array,
    spine_array_texture_region inValue,
  ) {
    return _spine_array_texture_region_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_texture_region_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_texture_region, spine_array_texture_region)>>(
          'spine_array_texture_region_add_all');
  late final _spine_array_texture_region_add_all = _spine_array_texture_region_add_allPtr
      .asFunction<void Function(spine_array_texture_region, spine_array_texture_region)>();

  void spine_array_texture_region_clear_and_add_all(
    spine_array_texture_region array,
    spine_array_texture_region inValue,
  ) {
    return _spine_array_texture_region_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_texture_region_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_texture_region, spine_array_texture_region)>>(
          'spine_array_texture_region_clear_and_add_all');
  late final _spine_array_texture_region_clear_and_add_all = _spine_array_texture_region_clear_and_add_allPtr
      .asFunction<void Function(spine_array_texture_region, spine_array_texture_region)>();

  void spine_array_texture_region_remove_at(
    spine_array_texture_region array,
    int inIndex,
  ) {
    return _spine_array_texture_region_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_texture_region_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_texture_region, ffi.Size)>>(
          'spine_array_texture_region_remove_at');
  late final _spine_array_texture_region_remove_at =
      _spine_array_texture_region_remove_atPtr.asFunction<void Function(spine_array_texture_region, int)>();

  bool spine_array_texture_region_contains(
    spine_array_texture_region array,
    spine_texture_region inValue,
  ) {
    return _spine_array_texture_region_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_texture_region_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_texture_region, spine_texture_region)>>(
          'spine_array_texture_region_contains');
  late final _spine_array_texture_region_contains = _spine_array_texture_region_containsPtr
      .asFunction<bool Function(spine_array_texture_region, spine_texture_region)>();

  int spine_array_texture_region_index_of(
    spine_array_texture_region array,
    spine_texture_region inValue,
  ) {
    return _spine_array_texture_region_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_texture_region_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_texture_region, spine_texture_region)>>(
          'spine_array_texture_region_index_of');
  late final _spine_array_texture_region_index_of = _spine_array_texture_region_index_ofPtr
      .asFunction<int Function(spine_array_texture_region, spine_texture_region)>();

  ffi.Pointer<spine_texture_region> spine_array_texture_region_buffer(
    spine_array_texture_region array,
  ) {
    return _spine_array_texture_region_buffer(
      array,
    );
  }

  late final _spine_array_texture_region_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_texture_region> Function(spine_array_texture_region)>>(
          'spine_array_texture_region_buffer');
  late final _spine_array_texture_region_buffer = _spine_array_texture_region_bufferPtr
      .asFunction<ffi.Pointer<spine_texture_region> Function(spine_array_texture_region)>();

  spine_array_timeline spine_array_timeline_create() {
    return _spine_array_timeline_create();
  }

  late final _spine_array_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_array_timeline Function()>>('spine_array_timeline_create');
  late final _spine_array_timeline_create =
      _spine_array_timeline_createPtr.asFunction<spine_array_timeline Function()>();

  spine_array_timeline spine_array_timeline_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_timeline_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_timeline_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_timeline Function(ffi.Size)>>('spine_array_timeline_create_with_capacity');
  late final _spine_array_timeline_create_with_capacity =
      _spine_array_timeline_create_with_capacityPtr.asFunction<spine_array_timeline Function(int)>();

  void spine_array_timeline_dispose(
    spine_array_timeline array,
  ) {
    return _spine_array_timeline_dispose(
      array,
    );
  }

  late final _spine_array_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_timeline)>>('spine_array_timeline_dispose');
  late final _spine_array_timeline_dispose =
      _spine_array_timeline_disposePtr.asFunction<void Function(spine_array_timeline)>();

  void spine_array_timeline_clear(
    spine_array_timeline array,
  ) {
    return _spine_array_timeline_clear(
      array,
    );
  }

  late final _spine_array_timeline_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_timeline)>>('spine_array_timeline_clear');
  late final _spine_array_timeline_clear =
      _spine_array_timeline_clearPtr.asFunction<void Function(spine_array_timeline)>();

  int spine_array_timeline_get_capacity(
    spine_array_timeline array,
  ) {
    return _spine_array_timeline_get_capacity(
      array,
    );
  }

  late final _spine_array_timeline_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_timeline)>>('spine_array_timeline_get_capacity');
  late final _spine_array_timeline_get_capacity =
      _spine_array_timeline_get_capacityPtr.asFunction<int Function(spine_array_timeline)>();

  int spine_array_timeline_size(
    spine_array_timeline array,
  ) {
    return _spine_array_timeline_size(
      array,
    );
  }

  late final _spine_array_timeline_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_timeline)>>('spine_array_timeline_size');
  late final _spine_array_timeline_size =
      _spine_array_timeline_sizePtr.asFunction<int Function(spine_array_timeline)>();

  spine_array_timeline spine_array_timeline_set_size(
    spine_array_timeline array,
    int newSize,
    spine_timeline defaultValue,
  ) {
    return _spine_array_timeline_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_timeline_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_timeline Function(spine_array_timeline, ffi.Size, spine_timeline)>>(
          'spine_array_timeline_set_size');
  late final _spine_array_timeline_set_size = _spine_array_timeline_set_sizePtr
      .asFunction<spine_array_timeline Function(spine_array_timeline, int, spine_timeline)>();

  void spine_array_timeline_ensure_capacity(
    spine_array_timeline array,
    int newCapacity,
  ) {
    return _spine_array_timeline_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_timeline_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_timeline, ffi.Size)>>(
          'spine_array_timeline_ensure_capacity');
  late final _spine_array_timeline_ensure_capacity =
      _spine_array_timeline_ensure_capacityPtr.asFunction<void Function(spine_array_timeline, int)>();

  void spine_array_timeline_add(
    spine_array_timeline array,
    spine_timeline inValue,
  ) {
    return _spine_array_timeline_add(
      array,
      inValue,
    );
  }

  late final _spine_array_timeline_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_timeline, spine_timeline)>>('spine_array_timeline_add');
  late final _spine_array_timeline_add =
      _spine_array_timeline_addPtr.asFunction<void Function(spine_array_timeline, spine_timeline)>();

  void spine_array_timeline_add_all(
    spine_array_timeline array,
    spine_array_timeline inValue,
  ) {
    return _spine_array_timeline_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_timeline_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_timeline, spine_array_timeline)>>(
          'spine_array_timeline_add_all');
  late final _spine_array_timeline_add_all =
      _spine_array_timeline_add_allPtr.asFunction<void Function(spine_array_timeline, spine_array_timeline)>();

  void spine_array_timeline_clear_and_add_all(
    spine_array_timeline array,
    spine_array_timeline inValue,
  ) {
    return _spine_array_timeline_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_timeline_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_timeline, spine_array_timeline)>>(
          'spine_array_timeline_clear_and_add_all');
  late final _spine_array_timeline_clear_and_add_all = _spine_array_timeline_clear_and_add_allPtr
      .asFunction<void Function(spine_array_timeline, spine_array_timeline)>();

  void spine_array_timeline_remove_at(
    spine_array_timeline array,
    int inIndex,
  ) {
    return _spine_array_timeline_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_timeline_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_timeline, ffi.Size)>>('spine_array_timeline_remove_at');
  late final _spine_array_timeline_remove_at =
      _spine_array_timeline_remove_atPtr.asFunction<void Function(spine_array_timeline, int)>();

  bool spine_array_timeline_contains(
    spine_array_timeline array,
    spine_timeline inValue,
  ) {
    return _spine_array_timeline_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_timeline_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_timeline, spine_timeline)>>(
          'spine_array_timeline_contains');
  late final _spine_array_timeline_contains =
      _spine_array_timeline_containsPtr.asFunction<bool Function(spine_array_timeline, spine_timeline)>();

  int spine_array_timeline_index_of(
    spine_array_timeline array,
    spine_timeline inValue,
  ) {
    return _spine_array_timeline_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_timeline_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_timeline, spine_timeline)>>(
          'spine_array_timeline_index_of');
  late final _spine_array_timeline_index_of =
      _spine_array_timeline_index_ofPtr.asFunction<int Function(spine_array_timeline, spine_timeline)>();

  ffi.Pointer<spine_timeline> spine_array_timeline_buffer(
    spine_array_timeline array,
  ) {
    return _spine_array_timeline_buffer(
      array,
    );
  }

  late final _spine_array_timeline_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_timeline> Function(spine_array_timeline)>>(
          'spine_array_timeline_buffer');
  late final _spine_array_timeline_buffer =
      _spine_array_timeline_bufferPtr.asFunction<ffi.Pointer<spine_timeline> Function(spine_array_timeline)>();

  spine_array_to_property spine_array_to_property_create() {
    return _spine_array_to_property_create();
  }

  late final _spine_array_to_property_createPtr =
      _lookup<ffi.NativeFunction<spine_array_to_property Function()>>('spine_array_to_property_create');
  late final _spine_array_to_property_create =
      _spine_array_to_property_createPtr.asFunction<spine_array_to_property Function()>();

  spine_array_to_property spine_array_to_property_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_to_property_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_to_property_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_to_property Function(ffi.Size)>>(
          'spine_array_to_property_create_with_capacity');
  late final _spine_array_to_property_create_with_capacity =
      _spine_array_to_property_create_with_capacityPtr.asFunction<spine_array_to_property Function(int)>();

  void spine_array_to_property_dispose(
    spine_array_to_property array,
  ) {
    return _spine_array_to_property_dispose(
      array,
    );
  }

  late final _spine_array_to_property_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_to_property)>>('spine_array_to_property_dispose');
  late final _spine_array_to_property_dispose =
      _spine_array_to_property_disposePtr.asFunction<void Function(spine_array_to_property)>();

  void spine_array_to_property_clear(
    spine_array_to_property array,
  ) {
    return _spine_array_to_property_clear(
      array,
    );
  }

  late final _spine_array_to_property_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_to_property)>>('spine_array_to_property_clear');
  late final _spine_array_to_property_clear =
      _spine_array_to_property_clearPtr.asFunction<void Function(spine_array_to_property)>();

  int spine_array_to_property_get_capacity(
    spine_array_to_property array,
  ) {
    return _spine_array_to_property_get_capacity(
      array,
    );
  }

  late final _spine_array_to_property_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_to_property)>>('spine_array_to_property_get_capacity');
  late final _spine_array_to_property_get_capacity =
      _spine_array_to_property_get_capacityPtr.asFunction<int Function(spine_array_to_property)>();

  int spine_array_to_property_size(
    spine_array_to_property array,
  ) {
    return _spine_array_to_property_size(
      array,
    );
  }

  late final _spine_array_to_property_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_to_property)>>('spine_array_to_property_size');
  late final _spine_array_to_property_size =
      _spine_array_to_property_sizePtr.asFunction<int Function(spine_array_to_property)>();

  spine_array_to_property spine_array_to_property_set_size(
    spine_array_to_property array,
    int newSize,
    spine_to_property defaultValue,
  ) {
    return _spine_array_to_property_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_to_property_set_sizePtr = _lookup<
          ffi.NativeFunction<spine_array_to_property Function(spine_array_to_property, ffi.Size, spine_to_property)>>(
      'spine_array_to_property_set_size');
  late final _spine_array_to_property_set_size = _spine_array_to_property_set_sizePtr
      .asFunction<spine_array_to_property Function(spine_array_to_property, int, spine_to_property)>();

  void spine_array_to_property_ensure_capacity(
    spine_array_to_property array,
    int newCapacity,
  ) {
    return _spine_array_to_property_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_to_property_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_to_property, ffi.Size)>>(
          'spine_array_to_property_ensure_capacity');
  late final _spine_array_to_property_ensure_capacity =
      _spine_array_to_property_ensure_capacityPtr.asFunction<void Function(spine_array_to_property, int)>();

  void spine_array_to_property_add(
    spine_array_to_property array,
    spine_to_property inValue,
  ) {
    return _spine_array_to_property_add(
      array,
      inValue,
    );
  }

  late final _spine_array_to_property_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_to_property, spine_to_property)>>(
          'spine_array_to_property_add');
  late final _spine_array_to_property_add =
      _spine_array_to_property_addPtr.asFunction<void Function(spine_array_to_property, spine_to_property)>();

  void spine_array_to_property_add_all(
    spine_array_to_property array,
    spine_array_to_property inValue,
  ) {
    return _spine_array_to_property_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_to_property_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_to_property, spine_array_to_property)>>(
          'spine_array_to_property_add_all');
  late final _spine_array_to_property_add_all =
      _spine_array_to_property_add_allPtr.asFunction<void Function(spine_array_to_property, spine_array_to_property)>();

  void spine_array_to_property_clear_and_add_all(
    spine_array_to_property array,
    spine_array_to_property inValue,
  ) {
    return _spine_array_to_property_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_to_property_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_to_property, spine_array_to_property)>>(
          'spine_array_to_property_clear_and_add_all');
  late final _spine_array_to_property_clear_and_add_all = _spine_array_to_property_clear_and_add_allPtr
      .asFunction<void Function(spine_array_to_property, spine_array_to_property)>();

  void spine_array_to_property_remove_at(
    spine_array_to_property array,
    int inIndex,
  ) {
    return _spine_array_to_property_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_to_property_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_to_property, ffi.Size)>>(
          'spine_array_to_property_remove_at');
  late final _spine_array_to_property_remove_at =
      _spine_array_to_property_remove_atPtr.asFunction<void Function(spine_array_to_property, int)>();

  bool spine_array_to_property_contains(
    spine_array_to_property array,
    spine_to_property inValue,
  ) {
    return _spine_array_to_property_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_to_property_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_to_property, spine_to_property)>>(
          'spine_array_to_property_contains');
  late final _spine_array_to_property_contains =
      _spine_array_to_property_containsPtr.asFunction<bool Function(spine_array_to_property, spine_to_property)>();

  int spine_array_to_property_index_of(
    spine_array_to_property array,
    spine_to_property inValue,
  ) {
    return _spine_array_to_property_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_to_property_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_to_property, spine_to_property)>>(
          'spine_array_to_property_index_of');
  late final _spine_array_to_property_index_of =
      _spine_array_to_property_index_ofPtr.asFunction<int Function(spine_array_to_property, spine_to_property)>();

  ffi.Pointer<spine_to_property> spine_array_to_property_buffer(
    spine_array_to_property array,
  ) {
    return _spine_array_to_property_buffer(
      array,
    );
  }

  late final _spine_array_to_property_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_to_property> Function(spine_array_to_property)>>(
          'spine_array_to_property_buffer');
  late final _spine_array_to_property_buffer =
      _spine_array_to_property_bufferPtr.asFunction<ffi.Pointer<spine_to_property> Function(spine_array_to_property)>();

  spine_array_track_entry spine_array_track_entry_create() {
    return _spine_array_track_entry_create();
  }

  late final _spine_array_track_entry_createPtr =
      _lookup<ffi.NativeFunction<spine_array_track_entry Function()>>('spine_array_track_entry_create');
  late final _spine_array_track_entry_create =
      _spine_array_track_entry_createPtr.asFunction<spine_array_track_entry Function()>();

  spine_array_track_entry spine_array_track_entry_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_track_entry_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_track_entry_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_track_entry Function(ffi.Size)>>(
          'spine_array_track_entry_create_with_capacity');
  late final _spine_array_track_entry_create_with_capacity =
      _spine_array_track_entry_create_with_capacityPtr.asFunction<spine_array_track_entry Function(int)>();

  void spine_array_track_entry_dispose(
    spine_array_track_entry array,
  ) {
    return _spine_array_track_entry_dispose(
      array,
    );
  }

  late final _spine_array_track_entry_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_track_entry)>>('spine_array_track_entry_dispose');
  late final _spine_array_track_entry_dispose =
      _spine_array_track_entry_disposePtr.asFunction<void Function(spine_array_track_entry)>();

  void spine_array_track_entry_clear(
    spine_array_track_entry array,
  ) {
    return _spine_array_track_entry_clear(
      array,
    );
  }

  late final _spine_array_track_entry_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_track_entry)>>('spine_array_track_entry_clear');
  late final _spine_array_track_entry_clear =
      _spine_array_track_entry_clearPtr.asFunction<void Function(spine_array_track_entry)>();

  int spine_array_track_entry_get_capacity(
    spine_array_track_entry array,
  ) {
    return _spine_array_track_entry_get_capacity(
      array,
    );
  }

  late final _spine_array_track_entry_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_track_entry)>>('spine_array_track_entry_get_capacity');
  late final _spine_array_track_entry_get_capacity =
      _spine_array_track_entry_get_capacityPtr.asFunction<int Function(spine_array_track_entry)>();

  int spine_array_track_entry_size(
    spine_array_track_entry array,
  ) {
    return _spine_array_track_entry_size(
      array,
    );
  }

  late final _spine_array_track_entry_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_track_entry)>>('spine_array_track_entry_size');
  late final _spine_array_track_entry_size =
      _spine_array_track_entry_sizePtr.asFunction<int Function(spine_array_track_entry)>();

  spine_array_track_entry spine_array_track_entry_set_size(
    spine_array_track_entry array,
    int newSize,
    spine_track_entry defaultValue,
  ) {
    return _spine_array_track_entry_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_track_entry_set_sizePtr = _lookup<
          ffi.NativeFunction<spine_array_track_entry Function(spine_array_track_entry, ffi.Size, spine_track_entry)>>(
      'spine_array_track_entry_set_size');
  late final _spine_array_track_entry_set_size = _spine_array_track_entry_set_sizePtr
      .asFunction<spine_array_track_entry Function(spine_array_track_entry, int, spine_track_entry)>();

  void spine_array_track_entry_ensure_capacity(
    spine_array_track_entry array,
    int newCapacity,
  ) {
    return _spine_array_track_entry_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_track_entry_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_track_entry, ffi.Size)>>(
          'spine_array_track_entry_ensure_capacity');
  late final _spine_array_track_entry_ensure_capacity =
      _spine_array_track_entry_ensure_capacityPtr.asFunction<void Function(spine_array_track_entry, int)>();

  void spine_array_track_entry_add(
    spine_array_track_entry array,
    spine_track_entry inValue,
  ) {
    return _spine_array_track_entry_add(
      array,
      inValue,
    );
  }

  late final _spine_array_track_entry_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_track_entry, spine_track_entry)>>(
          'spine_array_track_entry_add');
  late final _spine_array_track_entry_add =
      _spine_array_track_entry_addPtr.asFunction<void Function(spine_array_track_entry, spine_track_entry)>();

  void spine_array_track_entry_add_all(
    spine_array_track_entry array,
    spine_array_track_entry inValue,
  ) {
    return _spine_array_track_entry_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_track_entry_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_track_entry, spine_array_track_entry)>>(
          'spine_array_track_entry_add_all');
  late final _spine_array_track_entry_add_all =
      _spine_array_track_entry_add_allPtr.asFunction<void Function(spine_array_track_entry, spine_array_track_entry)>();

  void spine_array_track_entry_clear_and_add_all(
    spine_array_track_entry array,
    spine_array_track_entry inValue,
  ) {
    return _spine_array_track_entry_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_track_entry_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_track_entry, spine_array_track_entry)>>(
          'spine_array_track_entry_clear_and_add_all');
  late final _spine_array_track_entry_clear_and_add_all = _spine_array_track_entry_clear_and_add_allPtr
      .asFunction<void Function(spine_array_track_entry, spine_array_track_entry)>();

  void spine_array_track_entry_remove_at(
    spine_array_track_entry array,
    int inIndex,
  ) {
    return _spine_array_track_entry_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_track_entry_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_track_entry, ffi.Size)>>(
          'spine_array_track_entry_remove_at');
  late final _spine_array_track_entry_remove_at =
      _spine_array_track_entry_remove_atPtr.asFunction<void Function(spine_array_track_entry, int)>();

  bool spine_array_track_entry_contains(
    spine_array_track_entry array,
    spine_track_entry inValue,
  ) {
    return _spine_array_track_entry_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_track_entry_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_track_entry, spine_track_entry)>>(
          'spine_array_track_entry_contains');
  late final _spine_array_track_entry_contains =
      _spine_array_track_entry_containsPtr.asFunction<bool Function(spine_array_track_entry, spine_track_entry)>();

  int spine_array_track_entry_index_of(
    spine_array_track_entry array,
    spine_track_entry inValue,
  ) {
    return _spine_array_track_entry_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_track_entry_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_track_entry, spine_track_entry)>>(
          'spine_array_track_entry_index_of');
  late final _spine_array_track_entry_index_of =
      _spine_array_track_entry_index_ofPtr.asFunction<int Function(spine_array_track_entry, spine_track_entry)>();

  ffi.Pointer<spine_track_entry> spine_array_track_entry_buffer(
    spine_array_track_entry array,
  ) {
    return _spine_array_track_entry_buffer(
      array,
    );
  }

  late final _spine_array_track_entry_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_track_entry> Function(spine_array_track_entry)>>(
          'spine_array_track_entry_buffer');
  late final _spine_array_track_entry_buffer =
      _spine_array_track_entry_bufferPtr.asFunction<ffi.Pointer<spine_track_entry> Function(spine_array_track_entry)>();

  spine_array_update spine_array_update_create() {
    return _spine_array_update_create();
  }

  late final _spine_array_update_createPtr =
      _lookup<ffi.NativeFunction<spine_array_update Function()>>('spine_array_update_create');
  late final _spine_array_update_create = _spine_array_update_createPtr.asFunction<spine_array_update Function()>();

  spine_array_update spine_array_update_create_with_capacity(
    int initialCapacity,
  ) {
    return _spine_array_update_create_with_capacity(
      initialCapacity,
    );
  }

  late final _spine_array_update_create_with_capacityPtr =
      _lookup<ffi.NativeFunction<spine_array_update Function(ffi.Size)>>('spine_array_update_create_with_capacity');
  late final _spine_array_update_create_with_capacity =
      _spine_array_update_create_with_capacityPtr.asFunction<spine_array_update Function(int)>();

  void spine_array_update_dispose(
    spine_array_update array,
  ) {
    return _spine_array_update_dispose(
      array,
    );
  }

  late final _spine_array_update_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_update)>>('spine_array_update_dispose');
  late final _spine_array_update_dispose =
      _spine_array_update_disposePtr.asFunction<void Function(spine_array_update)>();

  void spine_array_update_clear(
    spine_array_update array,
  ) {
    return _spine_array_update_clear(
      array,
    );
  }

  late final _spine_array_update_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_update)>>('spine_array_update_clear');
  late final _spine_array_update_clear = _spine_array_update_clearPtr.asFunction<void Function(spine_array_update)>();

  int spine_array_update_get_capacity(
    spine_array_update array,
  ) {
    return _spine_array_update_get_capacity(
      array,
    );
  }

  late final _spine_array_update_get_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_update)>>('spine_array_update_get_capacity');
  late final _spine_array_update_get_capacity =
      _spine_array_update_get_capacityPtr.asFunction<int Function(spine_array_update)>();

  int spine_array_update_size(
    spine_array_update array,
  ) {
    return _spine_array_update_size(
      array,
    );
  }

  late final _spine_array_update_sizePtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_array_update)>>('spine_array_update_size');
  late final _spine_array_update_size = _spine_array_update_sizePtr.asFunction<int Function(spine_array_update)>();

  spine_array_update spine_array_update_set_size(
    spine_array_update array,
    int newSize,
    spine_update defaultValue,
  ) {
    return _spine_array_update_set_size(
      array,
      newSize,
      defaultValue,
    );
  }

  late final _spine_array_update_set_sizePtr =
      _lookup<ffi.NativeFunction<spine_array_update Function(spine_array_update, ffi.Size, spine_update)>>(
          'spine_array_update_set_size');
  late final _spine_array_update_set_size =
      _spine_array_update_set_sizePtr.asFunction<spine_array_update Function(spine_array_update, int, spine_update)>();

  void spine_array_update_ensure_capacity(
    spine_array_update array,
    int newCapacity,
  ) {
    return _spine_array_update_ensure_capacity(
      array,
      newCapacity,
    );
  }

  late final _spine_array_update_ensure_capacityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_update, ffi.Size)>>(
          'spine_array_update_ensure_capacity');
  late final _spine_array_update_ensure_capacity =
      _spine_array_update_ensure_capacityPtr.asFunction<void Function(spine_array_update, int)>();

  void spine_array_update_add(
    spine_array_update array,
    spine_update inValue,
  ) {
    return _spine_array_update_add(
      array,
      inValue,
    );
  }

  late final _spine_array_update_addPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_update, spine_update)>>('spine_array_update_add');
  late final _spine_array_update_add =
      _spine_array_update_addPtr.asFunction<void Function(spine_array_update, spine_update)>();

  void spine_array_update_add_all(
    spine_array_update array,
    spine_array_update inValue,
  ) {
    return _spine_array_update_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_update_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_update, spine_array_update)>>(
          'spine_array_update_add_all');
  late final _spine_array_update_add_all =
      _spine_array_update_add_allPtr.asFunction<void Function(spine_array_update, spine_array_update)>();

  void spine_array_update_clear_and_add_all(
    spine_array_update array,
    spine_array_update inValue,
  ) {
    return _spine_array_update_clear_and_add_all(
      array,
      inValue,
    );
  }

  late final _spine_array_update_clear_and_add_allPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_update, spine_array_update)>>(
          'spine_array_update_clear_and_add_all');
  late final _spine_array_update_clear_and_add_all =
      _spine_array_update_clear_and_add_allPtr.asFunction<void Function(spine_array_update, spine_array_update)>();

  void spine_array_update_remove_at(
    spine_array_update array,
    int inIndex,
  ) {
    return _spine_array_update_remove_at(
      array,
      inIndex,
    );
  }

  late final _spine_array_update_remove_atPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_update, ffi.Size)>>('spine_array_update_remove_at');
  late final _spine_array_update_remove_at =
      _spine_array_update_remove_atPtr.asFunction<void Function(spine_array_update, int)>();

  bool spine_array_update_contains(
    spine_array_update array,
    spine_update inValue,
  ) {
    return _spine_array_update_contains(
      array,
      inValue,
    );
  }

  late final _spine_array_update_containsPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_array_update, spine_update)>>('spine_array_update_contains');
  late final _spine_array_update_contains =
      _spine_array_update_containsPtr.asFunction<bool Function(spine_array_update, spine_update)>();

  int spine_array_update_index_of(
    spine_array_update array,
    spine_update inValue,
  ) {
    return _spine_array_update_index_of(
      array,
      inValue,
    );
  }

  late final _spine_array_update_index_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_update, spine_update)>>('spine_array_update_index_of');
  late final _spine_array_update_index_of =
      _spine_array_update_index_ofPtr.asFunction<int Function(spine_array_update, spine_update)>();

  ffi.Pointer<spine_update> spine_array_update_buffer(
    spine_array_update array,
  ) {
    return _spine_array_update_buffer(
      array,
    );
  }

  late final _spine_array_update_bufferPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_update> Function(spine_array_update)>>('spine_array_update_buffer');
  late final _spine_array_update_buffer =
      _spine_array_update_bufferPtr.asFunction<ffi.Pointer<spine_update> Function(spine_array_update)>();

  spine_bone_pose spine_bone_pose_create() {
    return _spine_bone_pose_create();
  }

  late final _spine_bone_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_bone_pose Function()>>('spine_bone_pose_create');
  late final _spine_bone_pose_create = _spine_bone_pose_createPtr.asFunction<spine_bone_pose Function()>();

  void spine_bone_pose_dispose(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_dispose(
      self,
    );
  }

  late final _spine_bone_pose_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose)>>('spine_bone_pose_dispose');
  late final _spine_bone_pose_dispose = _spine_bone_pose_disposePtr.asFunction<void Function(spine_bone_pose)>();

  spine_rtti spine_bone_pose_get_rtti(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_rtti(
      self,
    );
  }

  late final _spine_bone_pose_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_bone_pose)>>('spine_bone_pose_get_rtti');
  late final _spine_bone_pose_get_rtti =
      _spine_bone_pose_get_rttiPtr.asFunction<spine_rtti Function(spine_bone_pose)>();

  /// Called by Skeleton::updateCache() to compute the world transform, if needed.
  void spine_bone_pose_update(
    spine_bone_pose self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_bone_pose_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_bone_pose_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, spine_skeleton, ffi.Int32)>>(
          'spine_bone_pose_update');
  late final _spine_bone_pose_update =
      _spine_bone_pose_updatePtr.asFunction<void Function(spine_bone_pose, spine_skeleton, int)>();

  /// Computes the world transform using the parent bone's applied pose and this
  /// pose. Child bones are not updated.
  ///
  /// See World transforms in the Spine Runtimes Guide.
  void spine_bone_pose_update_world_transform(
    spine_bone_pose self,
    spine_skeleton skeleton,
  ) {
    return _spine_bone_pose_update_world_transform(
      self,
      skeleton,
    );
  }

  late final _spine_bone_pose_update_world_transformPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, spine_skeleton)>>(
          'spine_bone_pose_update_world_transform');
  late final _spine_bone_pose_update_world_transform =
      _spine_bone_pose_update_world_transformPtr.asFunction<void Function(spine_bone_pose, spine_skeleton)>();

  /// Computes the local transform values from the world transform.
  ///
  /// If the world transform is modified (by a constraint, rotateWorld(), etc) then
  /// this method should be called so the local transform matches the world
  /// transform. The local transform may be needed by other code (eg to apply
  /// another constraint).
  ///
  /// Some information is ambiguous in the world transform, such as -1,-1 scale
  /// versus 180 rotation. The local transform after calling this method is
  /// equivalent to the local transform used to compute the world transform, but
  /// may not be identical.
  void spine_bone_pose_update_local_transform(
    spine_bone_pose self,
    spine_skeleton skeleton,
  ) {
    return _spine_bone_pose_update_local_transform(
      self,
      skeleton,
    );
  }

  late final _spine_bone_pose_update_local_transformPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, spine_skeleton)>>(
          'spine_bone_pose_update_local_transform');
  late final _spine_bone_pose_update_local_transform =
      _spine_bone_pose_update_local_transformPtr.asFunction<void Function(spine_bone_pose, spine_skeleton)>();

  /// If the world transform has been modified and the local transform no longer
  /// matches, updateLocalTransform() is called.
  void spine_bone_pose_validate_local_transform(
    spine_bone_pose self,
    spine_skeleton skeleton,
  ) {
    return _spine_bone_pose_validate_local_transform(
      self,
      skeleton,
    );
  }

  late final _spine_bone_pose_validate_local_transformPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, spine_skeleton)>>(
          'spine_bone_pose_validate_local_transform');
  late final _spine_bone_pose_validate_local_transform =
      _spine_bone_pose_validate_local_transformPtr.asFunction<void Function(spine_bone_pose, spine_skeleton)>();

  void spine_bone_pose_modify_local(
    spine_bone_pose self,
    spine_skeleton skeleton,
  ) {
    return _spine_bone_pose_modify_local(
      self,
      skeleton,
    );
  }

  late final _spine_bone_pose_modify_localPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, spine_skeleton)>>('spine_bone_pose_modify_local');
  late final _spine_bone_pose_modify_local =
      _spine_bone_pose_modify_localPtr.asFunction<void Function(spine_bone_pose, spine_skeleton)>();

  void spine_bone_pose_modify_world(
    spine_bone_pose self,
    int update,
  ) {
    return _spine_bone_pose_modify_world(
      self,
      update,
    );
  }

  late final _spine_bone_pose_modify_worldPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Int)>>('spine_bone_pose_modify_world');
  late final _spine_bone_pose_modify_world =
      _spine_bone_pose_modify_worldPtr.asFunction<void Function(spine_bone_pose, int)>();

  void spine_bone_pose_reset_world(
    spine_bone_pose self,
    int update,
  ) {
    return _spine_bone_pose_reset_world(
      self,
      update,
    );
  }

  late final _spine_bone_pose_reset_worldPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Int)>>('spine_bone_pose_reset_world');
  late final _spine_bone_pose_reset_world =
      _spine_bone_pose_reset_worldPtr.asFunction<void Function(spine_bone_pose, int)>();

  /// Part of the world transform matrix for the X axis. If changed,
  /// updateLocalTransform() should be called.
  double spine_bone_pose_get_a(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_a(
      self,
    );
  }

  late final _spine_bone_pose_get_aPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_a');
  late final _spine_bone_pose_get_a = _spine_bone_pose_get_aPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_a(
    spine_bone_pose self,
    double a,
  ) {
    return _spine_bone_pose_set_a(
      self,
      a,
    );
  }

  late final _spine_bone_pose_set_aPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_a');
  late final _spine_bone_pose_set_a = _spine_bone_pose_set_aPtr.asFunction<void Function(spine_bone_pose, double)>();

  /// Part of the world transform matrix for the Y axis. If changed,
  /// updateLocalTransform() should be called.
  double spine_bone_pose_get_b(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_b(
      self,
    );
  }

  late final _spine_bone_pose_get_bPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_b');
  late final _spine_bone_pose_get_b = _spine_bone_pose_get_bPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_b(
    spine_bone_pose self,
    double b,
  ) {
    return _spine_bone_pose_set_b(
      self,
      b,
    );
  }

  late final _spine_bone_pose_set_bPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_b');
  late final _spine_bone_pose_set_b = _spine_bone_pose_set_bPtr.asFunction<void Function(spine_bone_pose, double)>();

  /// Part of the world transform matrix for the X axis. If changed,
  /// updateLocalTransform() should be called.
  double spine_bone_pose_get_c(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_c(
      self,
    );
  }

  late final _spine_bone_pose_get_cPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_c');
  late final _spine_bone_pose_get_c = _spine_bone_pose_get_cPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_c(
    spine_bone_pose self,
    double c,
  ) {
    return _spine_bone_pose_set_c(
      self,
      c,
    );
  }

  late final _spine_bone_pose_set_cPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_c');
  late final _spine_bone_pose_set_c = _spine_bone_pose_set_cPtr.asFunction<void Function(spine_bone_pose, double)>();

  /// Part of the world transform matrix for the Y axis. If changed,
  /// updateLocalTransform() should be called.
  double spine_bone_pose_get_d(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_d(
      self,
    );
  }

  late final _spine_bone_pose_get_dPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_d');
  late final _spine_bone_pose_get_d = _spine_bone_pose_get_dPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_d(
    spine_bone_pose self,
    double d,
  ) {
    return _spine_bone_pose_set_d(
      self,
      d,
    );
  }

  late final _spine_bone_pose_set_dPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_d');
  late final _spine_bone_pose_set_d = _spine_bone_pose_set_dPtr.asFunction<void Function(spine_bone_pose, double)>();

  /// The world X position. If changed, updateLocalTransform() should be called.
  double spine_bone_pose_get_world_x(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_world_x(
      self,
    );
  }

  late final _spine_bone_pose_get_world_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_world_x');
  late final _spine_bone_pose_get_world_x =
      _spine_bone_pose_get_world_xPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_world_x(
    spine_bone_pose self,
    double worldX,
  ) {
    return _spine_bone_pose_set_world_x(
      self,
      worldX,
    );
  }

  late final _spine_bone_pose_set_world_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_world_x');
  late final _spine_bone_pose_set_world_x =
      _spine_bone_pose_set_world_xPtr.asFunction<void Function(spine_bone_pose, double)>();

  /// The world Y position. If changed, updateLocalTransform() should be called.
  double spine_bone_pose_get_world_y(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_world_y(
      self,
    );
  }

  late final _spine_bone_pose_get_world_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_world_y');
  late final _spine_bone_pose_get_world_y =
      _spine_bone_pose_get_world_yPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_world_y(
    spine_bone_pose self,
    double worldY,
  ) {
    return _spine_bone_pose_set_world_y(
      self,
      worldY,
    );
  }

  late final _spine_bone_pose_set_world_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_world_y');
  late final _spine_bone_pose_set_world_y =
      _spine_bone_pose_set_world_yPtr.asFunction<void Function(spine_bone_pose, double)>();

  /// The world rotation for the X axis, calculated using a and c.
  double spine_bone_pose_get_world_rotation_x(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_world_rotation_x(
      self,
    );
  }

  late final _spine_bone_pose_get_world_rotation_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_world_rotation_x');
  late final _spine_bone_pose_get_world_rotation_x =
      _spine_bone_pose_get_world_rotation_xPtr.asFunction<double Function(spine_bone_pose)>();

  /// The world rotation for the Y axis, calculated using b and d.
  double spine_bone_pose_get_world_rotation_y(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_world_rotation_y(
      self,
    );
  }

  late final _spine_bone_pose_get_world_rotation_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_world_rotation_y');
  late final _spine_bone_pose_get_world_rotation_y =
      _spine_bone_pose_get_world_rotation_yPtr.asFunction<double Function(spine_bone_pose)>();

  /// The magnitude (always positive) of the world scale X, calculated using a and
  /// c.
  double spine_bone_pose_get_world_scale_x(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_world_scale_x(
      self,
    );
  }

  late final _spine_bone_pose_get_world_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_world_scale_x');
  late final _spine_bone_pose_get_world_scale_x =
      _spine_bone_pose_get_world_scale_xPtr.asFunction<double Function(spine_bone_pose)>();

  /// The magnitude (always positive) of the world scale Y, calculated using b and
  /// d.
  double spine_bone_pose_get_world_scale_y(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_world_scale_y(
      self,
    );
  }

  late final _spine_bone_pose_get_world_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_world_scale_y');
  late final _spine_bone_pose_get_world_scale_y =
      _spine_bone_pose_get_world_scale_yPtr.asFunction<double Function(spine_bone_pose)>();

  /// Transforms a point from world coordinates to the bone's local coordinates.
  void spine_bone_pose_world_to_local(
    spine_bone_pose self,
    double worldX,
    double worldY,
    ffi.Pointer<ffi.Float> outLocalX,
    ffi.Pointer<ffi.Float> outLocalY,
  ) {
    return _spine_bone_pose_world_to_local(
      self,
      worldX,
      worldY,
      outLocalX,
      outLocalY,
    );
  }

  late final _spine_bone_pose_world_to_localPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_pose, ffi.Float, ffi.Float, ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>>('spine_bone_pose_world_to_local');
  late final _spine_bone_pose_world_to_local = _spine_bone_pose_world_to_localPtr
      .asFunction<void Function(spine_bone_pose, double, double, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>)>();

  /// Transforms a point from the bone's local coordinates to world coordinates.
  void spine_bone_pose_local_to_world(
    spine_bone_pose self,
    double localX,
    double localY,
    ffi.Pointer<ffi.Float> outWorldX,
    ffi.Pointer<ffi.Float> outWorldY,
  ) {
    return _spine_bone_pose_local_to_world(
      self,
      localX,
      localY,
      outWorldX,
      outWorldY,
    );
  }

  late final _spine_bone_pose_local_to_worldPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_pose, ffi.Float, ffi.Float, ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>>('spine_bone_pose_local_to_world');
  late final _spine_bone_pose_local_to_world = _spine_bone_pose_local_to_worldPtr
      .asFunction<void Function(spine_bone_pose, double, double, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>)>();

  /// Transforms a point from world coordinates to the parent bone's local
  /// coordinates.
  void spine_bone_pose_world_to_parent(
    spine_bone_pose self,
    double worldX,
    double worldY,
    ffi.Pointer<ffi.Float> outParentX,
    ffi.Pointer<ffi.Float> outParentY,
  ) {
    return _spine_bone_pose_world_to_parent(
      self,
      worldX,
      worldY,
      outParentX,
      outParentY,
    );
  }

  late final _spine_bone_pose_world_to_parentPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_pose, ffi.Float, ffi.Float, ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>>('spine_bone_pose_world_to_parent');
  late final _spine_bone_pose_world_to_parent = _spine_bone_pose_world_to_parentPtr
      .asFunction<void Function(spine_bone_pose, double, double, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>)>();

  /// Transforms a point from the parent bone's coordinates to world coordinates.
  void spine_bone_pose_parent_to_world(
    spine_bone_pose self,
    double parentX,
    double parentY,
    ffi.Pointer<ffi.Float> outWorldX,
    ffi.Pointer<ffi.Float> outWorldY,
  ) {
    return _spine_bone_pose_parent_to_world(
      self,
      parentX,
      parentY,
      outWorldX,
      outWorldY,
    );
  }

  late final _spine_bone_pose_parent_to_worldPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_pose, ffi.Float, ffi.Float, ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>>('spine_bone_pose_parent_to_world');
  late final _spine_bone_pose_parent_to_world = _spine_bone_pose_parent_to_worldPtr
      .asFunction<void Function(spine_bone_pose, double, double, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>)>();

  /// Transforms a world rotation to a local rotation.
  double spine_bone_pose_world_to_local_rotation(
    spine_bone_pose self,
    double worldRotation,
  ) {
    return _spine_bone_pose_world_to_local_rotation(
      self,
      worldRotation,
    );
  }

  late final _spine_bone_pose_world_to_local_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose, ffi.Float)>>(
          'spine_bone_pose_world_to_local_rotation');
  late final _spine_bone_pose_world_to_local_rotation =
      _spine_bone_pose_world_to_local_rotationPtr.asFunction<double Function(spine_bone_pose, double)>();

  /// Transforms a local rotation to a world rotation.
  double spine_bone_pose_local_to_world_rotation(
    spine_bone_pose self,
    double localRotation,
  ) {
    return _spine_bone_pose_local_to_world_rotation(
      self,
      localRotation,
    );
  }

  late final _spine_bone_pose_local_to_world_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose, ffi.Float)>>(
          'spine_bone_pose_local_to_world_rotation');
  late final _spine_bone_pose_local_to_world_rotation =
      _spine_bone_pose_local_to_world_rotationPtr.asFunction<double Function(spine_bone_pose, double)>();

  /// Rotates the world transform the specified amount.
  ///
  /// After changes are made to the world transform, updateLocalTransform() should
  /// be called on this bone and any child bones, recursively.
  void spine_bone_pose_rotate_world(
    spine_bone_pose self,
    double degrees,
  ) {
    return _spine_bone_pose_rotate_world(
      self,
      degrees,
    );
  }

  late final _spine_bone_pose_rotate_worldPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_rotate_world');
  late final _spine_bone_pose_rotate_world =
      _spine_bone_pose_rotate_worldPtr.asFunction<void Function(spine_bone_pose, double)>();

  void spine_bone_pose_set(
    spine_bone_pose self,
    spine_bone_local pose,
  ) {
    return _spine_bone_pose_set(
      self,
      pose,
    );
  }

  late final _spine_bone_pose_setPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, spine_bone_local)>>('spine_bone_pose_set');
  late final _spine_bone_pose_set =
      _spine_bone_pose_setPtr.asFunction<void Function(spine_bone_pose, spine_bone_local)>();

  /// The local x translation.
  double spine_bone_pose_get_x(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_x(
      self,
    );
  }

  late final _spine_bone_pose_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_x');
  late final _spine_bone_pose_get_x = _spine_bone_pose_get_xPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_x(
    spine_bone_pose self,
    double x,
  ) {
    return _spine_bone_pose_set_x(
      self,
      x,
    );
  }

  late final _spine_bone_pose_set_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_x');
  late final _spine_bone_pose_set_x = _spine_bone_pose_set_xPtr.asFunction<void Function(spine_bone_pose, double)>();

  /// The local y translation.
  double spine_bone_pose_get_y(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_y(
      self,
    );
  }

  late final _spine_bone_pose_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_y');
  late final _spine_bone_pose_get_y = _spine_bone_pose_get_yPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_y(
    spine_bone_pose self,
    double y,
  ) {
    return _spine_bone_pose_set_y(
      self,
      y,
    );
  }

  late final _spine_bone_pose_set_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_y');
  late final _spine_bone_pose_set_y = _spine_bone_pose_set_yPtr.asFunction<void Function(spine_bone_pose, double)>();

  void spine_bone_pose_set_position(
    spine_bone_pose self,
    double x,
    double y,
  ) {
    return _spine_bone_pose_set_position(
      self,
      x,
      y,
    );
  }

  late final _spine_bone_pose_set_positionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float, ffi.Float)>>(
          'spine_bone_pose_set_position');
  late final _spine_bone_pose_set_position =
      _spine_bone_pose_set_positionPtr.asFunction<void Function(spine_bone_pose, double, double)>();

  /// The local rotation in degrees, counter clockwise.
  double spine_bone_pose_get_rotation(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_rotation(
      self,
    );
  }

  late final _spine_bone_pose_get_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_rotation');
  late final _spine_bone_pose_get_rotation =
      _spine_bone_pose_get_rotationPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_rotation(
    spine_bone_pose self,
    double rotation,
  ) {
    return _spine_bone_pose_set_rotation(
      self,
      rotation,
    );
  }

  late final _spine_bone_pose_set_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_rotation');
  late final _spine_bone_pose_set_rotation =
      _spine_bone_pose_set_rotationPtr.asFunction<void Function(spine_bone_pose, double)>();

  /// The local scaleX.
  double spine_bone_pose_get_scale_x(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_scale_x(
      self,
    );
  }

  late final _spine_bone_pose_get_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_scale_x');
  late final _spine_bone_pose_get_scale_x =
      _spine_bone_pose_get_scale_xPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_scale_x(
    spine_bone_pose self,
    double scaleX,
  ) {
    return _spine_bone_pose_set_scale_x(
      self,
      scaleX,
    );
  }

  late final _spine_bone_pose_set_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_scale_x');
  late final _spine_bone_pose_set_scale_x =
      _spine_bone_pose_set_scale_xPtr.asFunction<void Function(spine_bone_pose, double)>();

  /// The local scaleY.
  double spine_bone_pose_get_scale_y(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_scale_y(
      self,
    );
  }

  late final _spine_bone_pose_get_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_scale_y');
  late final _spine_bone_pose_get_scale_y =
      _spine_bone_pose_get_scale_yPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_scale_y(
    spine_bone_pose self,
    double scaleY,
  ) {
    return _spine_bone_pose_set_scale_y(
      self,
      scaleY,
    );
  }

  late final _spine_bone_pose_set_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_scale_y');
  late final _spine_bone_pose_set_scale_y =
      _spine_bone_pose_set_scale_yPtr.asFunction<void Function(spine_bone_pose, double)>();

  void spine_bone_pose_set_scale_1(
    spine_bone_pose self,
    double scaleX,
    double scaleY,
  ) {
    return _spine_bone_pose_set_scale_1(
      self,
      scaleX,
      scaleY,
    );
  }

  late final _spine_bone_pose_set_scale_1Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float, ffi.Float)>>(
          'spine_bone_pose_set_scale_1');
  late final _spine_bone_pose_set_scale_1 =
      _spine_bone_pose_set_scale_1Ptr.asFunction<void Function(spine_bone_pose, double, double)>();

  void spine_bone_pose_set_scale_2(
    spine_bone_pose self,
    double scale,
  ) {
    return _spine_bone_pose_set_scale_2(
      self,
      scale,
    );
  }

  late final _spine_bone_pose_set_scale_2Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_scale_2');
  late final _spine_bone_pose_set_scale_2 =
      _spine_bone_pose_set_scale_2Ptr.asFunction<void Function(spine_bone_pose, double)>();

  /// The local shearX.
  double spine_bone_pose_get_shear_x(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_shear_x(
      self,
    );
  }

  late final _spine_bone_pose_get_shear_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_shear_x');
  late final _spine_bone_pose_get_shear_x =
      _spine_bone_pose_get_shear_xPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_shear_x(
    spine_bone_pose self,
    double shearX,
  ) {
    return _spine_bone_pose_set_shear_x(
      self,
      shearX,
    );
  }

  late final _spine_bone_pose_set_shear_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_shear_x');
  late final _spine_bone_pose_set_shear_x =
      _spine_bone_pose_set_shear_xPtr.asFunction<void Function(spine_bone_pose, double)>();

  /// The local shearY.
  double spine_bone_pose_get_shear_y(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_shear_y(
      self,
    );
  }

  late final _spine_bone_pose_get_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>('spine_bone_pose_get_shear_y');
  late final _spine_bone_pose_get_shear_y =
      _spine_bone_pose_get_shear_yPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_shear_y(
    spine_bone_pose self,
    double shearY,
  ) {
    return _spine_bone_pose_set_shear_y(
      self,
      shearY,
    );
  }

  late final _spine_bone_pose_set_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>('spine_bone_pose_set_shear_y');
  late final _spine_bone_pose_set_shear_y =
      _spine_bone_pose_set_shear_yPtr.asFunction<void Function(spine_bone_pose, double)>();

  /// Determines how parent world transforms affect this bone.
  int spine_bone_pose_get_inherit(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_inherit(
      self,
    );
  }

  late final _spine_bone_pose_get_inheritPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_bone_pose)>>('spine_bone_pose_get_inherit');
  late final _spine_bone_pose_get_inherit = _spine_bone_pose_get_inheritPtr.asFunction<int Function(spine_bone_pose)>();

  void spine_bone_pose_set_inherit(
    spine_bone_pose self,
    int inherit,
  ) {
    return _spine_bone_pose_set_inherit(
      self,
      inherit,
    );
  }

  late final _spine_bone_pose_set_inheritPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Int32)>>('spine_bone_pose_set_inherit');
  late final _spine_bone_pose_set_inherit =
      _spine_bone_pose_set_inheritPtr.asFunction<void Function(spine_bone_pose, int)>();

  spine_rtti spine_bone_pose_rtti() {
    return _spine_bone_pose_rtti();
  }

  late final _spine_bone_pose_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_bone_pose_rtti');
  late final _spine_bone_pose_rtti = _spine_bone_pose_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_atlas_dispose(
    spine_atlas self,
  ) {
    return _spine_atlas_dispose(
      self,
    );
  }

  late final _spine_atlas_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas)>>('spine_atlas_dispose');
  late final _spine_atlas_dispose = _spine_atlas_disposePtr.asFunction<void Function(spine_atlas)>();

  void spine_atlas_flip_v(
    spine_atlas self,
  ) {
    return _spine_atlas_flip_v(
      self,
    );
  }

  late final _spine_atlas_flip_vPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas)>>('spine_atlas_flip_v');
  late final _spine_atlas_flip_v = _spine_atlas_flip_vPtr.asFunction<void Function(spine_atlas)>();

  spine_atlas_region spine_atlas_find_region(
    spine_atlas self,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_atlas_find_region(
      self,
      name,
    );
  }

  late final _spine_atlas_find_regionPtr =
      _lookup<ffi.NativeFunction<spine_atlas_region Function(spine_atlas, ffi.Pointer<ffi.Char>)>>(
          'spine_atlas_find_region');
  late final _spine_atlas_find_region =
      _spine_atlas_find_regionPtr.asFunction<spine_atlas_region Function(spine_atlas, ffi.Pointer<ffi.Char>)>();

  spine_array_atlas_page spine_atlas_get_pages(
    spine_atlas self,
  ) {
    return _spine_atlas_get_pages(
      self,
    );
  }

  late final _spine_atlas_get_pagesPtr =
      _lookup<ffi.NativeFunction<spine_array_atlas_page Function(spine_atlas)>>('spine_atlas_get_pages');
  late final _spine_atlas_get_pages =
      _spine_atlas_get_pagesPtr.asFunction<spine_array_atlas_page Function(spine_atlas)>();

  spine_array_atlas_region spine_atlas_get_regions(
    spine_atlas self,
  ) {
    return _spine_atlas_get_regions(
      self,
    );
  }

  late final _spine_atlas_get_regionsPtr =
      _lookup<ffi.NativeFunction<spine_array_atlas_region Function(spine_atlas)>>('spine_atlas_get_regions');
  late final _spine_atlas_get_regions =
      _spine_atlas_get_regionsPtr.asFunction<spine_array_atlas_region Function(spine_atlas)>();

  spine_skeleton_data spine_skeleton_data_create() {
    return _spine_skeleton_data_create();
  }

  late final _spine_skeleton_data_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_data Function()>>('spine_skeleton_data_create');
  late final _spine_skeleton_data_create = _spine_skeleton_data_createPtr.asFunction<spine_skeleton_data Function()>();

  void spine_skeleton_data_dispose(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_dispose(
      self,
    );
  }

  late final _spine_skeleton_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data)>>('spine_skeleton_data_dispose');
  late final _spine_skeleton_data_dispose =
      _spine_skeleton_data_disposePtr.asFunction<void Function(spine_skeleton_data)>();

  spine_bone_data spine_skeleton_data_find_bone(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> boneName,
  ) {
    return _spine_skeleton_data_find_bone(
      self,
      boneName,
    );
  }

  late final _spine_skeleton_data_find_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_data_find_bone');
  late final _spine_skeleton_data_find_bone = _spine_skeleton_data_find_bonePtr
      .asFunction<spine_bone_data Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  spine_slot_data spine_skeleton_data_find_slot(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> slotName,
  ) {
    return _spine_skeleton_data_find_slot(
      self,
      slotName,
    );
  }

  late final _spine_skeleton_data_find_slotPtr =
      _lookup<ffi.NativeFunction<spine_slot_data Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_data_find_slot');
  late final _spine_skeleton_data_find_slot = _spine_skeleton_data_find_slotPtr
      .asFunction<spine_slot_data Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  spine_skin spine_skeleton_data_find_skin(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> skinName,
  ) {
    return _spine_skeleton_data_find_skin(
      self,
      skinName,
    );
  }

  late final _spine_skeleton_data_find_skinPtr =
      _lookup<ffi.NativeFunction<spine_skin Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_data_find_skin');
  late final _spine_skeleton_data_find_skin =
      _spine_skeleton_data_find_skinPtr.asFunction<spine_skin Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  spine_event_data spine_skeleton_data_find_event(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> eventDataName,
  ) {
    return _spine_skeleton_data_find_event(
      self,
      eventDataName,
    );
  }

  late final _spine_skeleton_data_find_eventPtr =
      _lookup<ffi.NativeFunction<spine_event_data Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_data_find_event');
  late final _spine_skeleton_data_find_event = _spine_skeleton_data_find_eventPtr
      .asFunction<spine_event_data Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  spine_animation spine_skeleton_data_find_animation(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> animationName,
  ) {
    return _spine_skeleton_data_find_animation(
      self,
      animationName,
    );
  }

  late final _spine_skeleton_data_find_animationPtr =
      _lookup<ffi.NativeFunction<spine_animation Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_data_find_animation');
  late final _spine_skeleton_data_find_animation = _spine_skeleton_data_find_animationPtr
      .asFunction<spine_animation Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  /// The skeleton's name, which by default is the name of the skeleton data file
  /// when possible, or null when a name hasn't been set.
  ffi.Pointer<ffi.Char> spine_skeleton_data_get_name(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_name(
      self,
    );
  }

  late final _spine_skeleton_data_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>>('spine_skeleton_data_get_name');
  late final _spine_skeleton_data_get_name =
      _spine_skeleton_data_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_name(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_skeleton_data_set_name(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_namePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_data_set_name');
  late final _spine_skeleton_data_set_name =
      _spine_skeleton_data_set_namePtr.asFunction<void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  /// The skeleton's bones, sorted parent first. The root bone is always the first
  /// bone.
  spine_array_bone_data spine_skeleton_data_get_bones(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_bones(
      self,
    );
  }

  late final _spine_skeleton_data_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_bone_data Function(spine_skeleton_data)>>('spine_skeleton_data_get_bones');
  late final _spine_skeleton_data_get_bones =
      _spine_skeleton_data_get_bonesPtr.asFunction<spine_array_bone_data Function(spine_skeleton_data)>();

  /// The skeleton's slots in the setup pose draw order.
  spine_array_slot_data spine_skeleton_data_get_slots(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_slots(
      self,
    );
  }

  late final _spine_skeleton_data_get_slotsPtr =
      _lookup<ffi.NativeFunction<spine_array_slot_data Function(spine_skeleton_data)>>('spine_skeleton_data_get_slots');
  late final _spine_skeleton_data_get_slots =
      _spine_skeleton_data_get_slotsPtr.asFunction<spine_array_slot_data Function(spine_skeleton_data)>();

  /// All skins, including the default skin.
  spine_array_skin spine_skeleton_data_get_skins(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_skins(
      self,
    );
  }

  late final _spine_skeleton_data_get_skinsPtr =
      _lookup<ffi.NativeFunction<spine_array_skin Function(spine_skeleton_data)>>('spine_skeleton_data_get_skins');
  late final _spine_skeleton_data_get_skins =
      _spine_skeleton_data_get_skinsPtr.asFunction<spine_array_skin Function(spine_skeleton_data)>();

  spine_skin spine_skeleton_data_get_default_skin(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_default_skin(
      self,
    );
  }

  late final _spine_skeleton_data_get_default_skinPtr =
      _lookup<ffi.NativeFunction<spine_skin Function(spine_skeleton_data)>>('spine_skeleton_data_get_default_skin');
  late final _spine_skeleton_data_get_default_skin =
      _spine_skeleton_data_get_default_skinPtr.asFunction<spine_skin Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_default_skin(
    spine_skeleton_data self,
    spine_skin inValue,
  ) {
    return _spine_skeleton_data_set_default_skin(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_default_skinPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, spine_skin)>>(
          'spine_skeleton_data_set_default_skin');
  late final _spine_skeleton_data_set_default_skin =
      _spine_skeleton_data_set_default_skinPtr.asFunction<void Function(spine_skeleton_data, spine_skin)>();

  /// The skeleton's events.
  spine_array_event_data spine_skeleton_data_get_events(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_events(
      self,
    );
  }

  late final _spine_skeleton_data_get_eventsPtr =
      _lookup<ffi.NativeFunction<spine_array_event_data Function(spine_skeleton_data)>>(
          'spine_skeleton_data_get_events');
  late final _spine_skeleton_data_get_events =
      _spine_skeleton_data_get_eventsPtr.asFunction<spine_array_event_data Function(spine_skeleton_data)>();

  /// The skeleton's animations.
  spine_array_animation spine_skeleton_data_get_animations(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_animations(
      self,
    );
  }

  late final _spine_skeleton_data_get_animationsPtr =
      _lookup<ffi.NativeFunction<spine_array_animation Function(spine_skeleton_data)>>(
          'spine_skeleton_data_get_animations');
  late final _spine_skeleton_data_get_animations =
      _spine_skeleton_data_get_animationsPtr.asFunction<spine_array_animation Function(spine_skeleton_data)>();

  /// The skeleton's constraints.
  spine_array_constraint_data spine_skeleton_data_get_constraints(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_constraints(
      self,
    );
  }

  late final _spine_skeleton_data_get_constraintsPtr =
      _lookup<ffi.NativeFunction<spine_array_constraint_data Function(spine_skeleton_data)>>(
          'spine_skeleton_data_get_constraints');
  late final _spine_skeleton_data_get_constraints =
      _spine_skeleton_data_get_constraintsPtr.asFunction<spine_array_constraint_data Function(spine_skeleton_data)>();

  /// The X coordinate of the skeleton's axis aligned bounding box in the setup
  /// pose.
  double spine_skeleton_data_get_x(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_x(
      self,
    );
  }

  late final _spine_skeleton_data_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>('spine_skeleton_data_get_x');
  late final _spine_skeleton_data_get_x =
      _spine_skeleton_data_get_xPtr.asFunction<double Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_x(
    spine_skeleton_data self,
    double inValue,
  ) {
    return _spine_skeleton_data_set_x(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>('spine_skeleton_data_set_x');
  late final _spine_skeleton_data_set_x =
      _spine_skeleton_data_set_xPtr.asFunction<void Function(spine_skeleton_data, double)>();

  /// The Y coordinate of the skeleton's axis aligned bounding box in the setup
  /// pose.
  double spine_skeleton_data_get_y(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_y(
      self,
    );
  }

  late final _spine_skeleton_data_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>('spine_skeleton_data_get_y');
  late final _spine_skeleton_data_get_y =
      _spine_skeleton_data_get_yPtr.asFunction<double Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_y(
    spine_skeleton_data self,
    double inValue,
  ) {
    return _spine_skeleton_data_set_y(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>('spine_skeleton_data_set_y');
  late final _spine_skeleton_data_set_y =
      _spine_skeleton_data_set_yPtr.asFunction<void Function(spine_skeleton_data, double)>();

  /// The width of the skeleton's axis aligned bounding box in the setup pose.
  double spine_skeleton_data_get_width(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_width(
      self,
    );
  }

  late final _spine_skeleton_data_get_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>('spine_skeleton_data_get_width');
  late final _spine_skeleton_data_get_width =
      _spine_skeleton_data_get_widthPtr.asFunction<double Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_width(
    spine_skeleton_data self,
    double inValue,
  ) {
    return _spine_skeleton_data_set_width(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>('spine_skeleton_data_set_width');
  late final _spine_skeleton_data_set_width =
      _spine_skeleton_data_set_widthPtr.asFunction<void Function(spine_skeleton_data, double)>();

  /// The height of the skeleton's axis aligned bounding box in the setup pose.
  double spine_skeleton_data_get_height(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_height(
      self,
    );
  }

  late final _spine_skeleton_data_get_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>('spine_skeleton_data_get_height');
  late final _spine_skeleton_data_get_height =
      _spine_skeleton_data_get_heightPtr.asFunction<double Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_height(
    spine_skeleton_data self,
    double inValue,
  ) {
    return _spine_skeleton_data_set_height(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>('spine_skeleton_data_set_height');
  late final _spine_skeleton_data_set_height =
      _spine_skeleton_data_set_heightPtr.asFunction<void Function(spine_skeleton_data, double)>();

  /// Baseline scale factor for applying physics and other effects based on
  /// distance to non-scalable properties, such as angle or scale. Default is 100.
  double spine_skeleton_data_get_reference_scale(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_reference_scale(
      self,
    );
  }

  late final _spine_skeleton_data_get_reference_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>('spine_skeleton_data_get_reference_scale');
  late final _spine_skeleton_data_get_reference_scale =
      _spine_skeleton_data_get_reference_scalePtr.asFunction<double Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_reference_scale(
    spine_skeleton_data self,
    double inValue,
  ) {
    return _spine_skeleton_data_set_reference_scale(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_reference_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>(
          'spine_skeleton_data_set_reference_scale');
  late final _spine_skeleton_data_set_reference_scale =
      _spine_skeleton_data_set_reference_scalePtr.asFunction<void Function(spine_skeleton_data, double)>();

  /// The Spine version used to export this data, or NULL.
  ffi.Pointer<ffi.Char> spine_skeleton_data_get_version(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_version(
      self,
    );
  }

  late final _spine_skeleton_data_get_versionPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>>(
          'spine_skeleton_data_get_version');
  late final _spine_skeleton_data_get_version =
      _spine_skeleton_data_get_versionPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_version(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_skeleton_data_set_version(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_versionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_data_set_version');
  late final _spine_skeleton_data_set_version =
      _spine_skeleton_data_set_versionPtr.asFunction<void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  /// The skeleton data hash. This value will change if any of the skeleton data
  /// has changed.
  ffi.Pointer<ffi.Char> spine_skeleton_data_get_hash(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_hash(
      self,
    );
  }

  late final _spine_skeleton_data_get_hashPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>>('spine_skeleton_data_get_hash');
  late final _spine_skeleton_data_get_hash =
      _spine_skeleton_data_get_hashPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_hash(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_skeleton_data_set_hash(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_hashPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_data_set_hash');
  late final _spine_skeleton_data_set_hash =
      _spine_skeleton_data_set_hashPtr.asFunction<void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  /// The path to the images directory as defined in Spine, or null if nonessential
  /// data was not exported.
  ffi.Pointer<ffi.Char> spine_skeleton_data_get_images_path(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_images_path(
      self,
    );
  }

  late final _spine_skeleton_data_get_images_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>>(
          'spine_skeleton_data_get_images_path');
  late final _spine_skeleton_data_get_images_path =
      _spine_skeleton_data_get_images_pathPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_images_path(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_skeleton_data_set_images_path(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_images_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_data_set_images_path');
  late final _spine_skeleton_data_set_images_path =
      _spine_skeleton_data_set_images_pathPtr.asFunction<void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  /// The path to the audio directory as defined in Spine, or null if nonessential
  /// data was not exported.
  ffi.Pointer<ffi.Char> spine_skeleton_data_get_audio_path(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_audio_path(
      self,
    );
  }

  late final _spine_skeleton_data_get_audio_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>>(
          'spine_skeleton_data_get_audio_path');
  late final _spine_skeleton_data_get_audio_path =
      _spine_skeleton_data_get_audio_pathPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_audio_path(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_skeleton_data_set_audio_path(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_audio_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_data_set_audio_path');
  late final _spine_skeleton_data_set_audio_path =
      _spine_skeleton_data_set_audio_pathPtr.asFunction<void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  /// The dopesheet FPS in Spine. Available only when nonessential data was
  /// exported.
  double spine_skeleton_data_get_fps(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_fps(
      self,
    );
  }

  late final _spine_skeleton_data_get_fpsPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>('spine_skeleton_data_get_fps');
  late final _spine_skeleton_data_get_fps =
      _spine_skeleton_data_get_fpsPtr.asFunction<double Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_fps(
    spine_skeleton_data self,
    double inValue,
  ) {
    return _spine_skeleton_data_set_fps(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_fpsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>('spine_skeleton_data_set_fps');
  late final _spine_skeleton_data_set_fps =
      _spine_skeleton_data_set_fpsPtr.asFunction<void Function(spine_skeleton_data, double)>();

  /// Version functions
  int spine_major_version() {
    return _spine_major_version();
  }

  late final _spine_major_versionPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function()>>('spine_major_version');
  late final _spine_major_version = _spine_major_versionPtr.asFunction<int Function()>();

  int spine_minor_version() {
    return _spine_minor_version();
  }

  late final _spine_minor_versionPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function()>>('spine_minor_version');
  late final _spine_minor_version = _spine_minor_versionPtr.asFunction<int Function()>();

  void spine_enable_debug_extension(
    bool enable,
  ) {
    return _spine_enable_debug_extension(
      enable,
    );
  }

  late final _spine_enable_debug_extensionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Bool)>>('spine_enable_debug_extension');
  late final _spine_enable_debug_extension = _spine_enable_debug_extensionPtr.asFunction<void Function(bool)>();

  void spine_report_leaks() {
    return _spine_report_leaks();
  }

  late final _spine_report_leaksPtr = _lookup<ffi.NativeFunction<ffi.Void Function()>>('spine_report_leaks');
  late final _spine_report_leaks = _spine_report_leaksPtr.asFunction<void Function()>();

  /// Atlas functions
  spine_atlas_result spine_atlas_load(
    ffi.Pointer<ffi.Char> atlasData,
  ) {
    return _spine_atlas_load(
      atlasData,
    );
  }

  late final _spine_atlas_loadPtr =
      _lookup<ffi.NativeFunction<spine_atlas_result Function(ffi.Pointer<ffi.Char>)>>('spine_atlas_load');
  late final _spine_atlas_load = _spine_atlas_loadPtr.asFunction<spine_atlas_result Function(ffi.Pointer<ffi.Char>)>();

  spine_atlas_result spine_atlas_load_callback(
    ffi.Pointer<ffi.Char> atlasData,
    ffi.Pointer<ffi.Char> atlasDir,
    spine_texture_loader_load_func load,
    spine_texture_loader_unload_func unload,
  ) {
    return _spine_atlas_load_callback(
      atlasData,
      atlasDir,
      load,
      unload,
    );
  }

  late final _spine_atlas_load_callbackPtr = _lookup<
      ffi.NativeFunction<
          spine_atlas_result Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, spine_texture_loader_load_func,
              spine_texture_loader_unload_func)>>('spine_atlas_load_callback');
  late final _spine_atlas_load_callback = _spine_atlas_load_callbackPtr.asFunction<
      spine_atlas_result Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, spine_texture_loader_load_func,
          spine_texture_loader_unload_func)>();

  ffi.Pointer<ffi.Char> spine_atlas_result_get_error(
    spine_atlas_result result,
  ) {
    return _spine_atlas_result_get_error(
      result,
    );
  }

  late final _spine_atlas_result_get_errorPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_atlas_result)>>('spine_atlas_result_get_error');
  late final _spine_atlas_result_get_error =
      _spine_atlas_result_get_errorPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_atlas_result)>();

  spine_atlas spine_atlas_result_get_atlas(
    spine_atlas_result result,
  ) {
    return _spine_atlas_result_get_atlas(
      result,
    );
  }

  late final _spine_atlas_result_get_atlasPtr =
      _lookup<ffi.NativeFunction<spine_atlas Function(spine_atlas_result)>>('spine_atlas_result_get_atlas');
  late final _spine_atlas_result_get_atlas =
      _spine_atlas_result_get_atlasPtr.asFunction<spine_atlas Function(spine_atlas_result)>();

  void spine_atlas_result_dispose(
    spine_atlas_result result,
  ) {
    return _spine_atlas_result_dispose(
      result,
    );
  }

  late final _spine_atlas_result_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_result)>>('spine_atlas_result_dispose');
  late final _spine_atlas_result_dispose =
      _spine_atlas_result_disposePtr.asFunction<void Function(spine_atlas_result)>();

  /// Skeleton data functions
  spine_skeleton_data_result spine_skeleton_data_load_json(
    spine_atlas atlas,
    ffi.Pointer<ffi.Char> skeletonData,
    ffi.Pointer<ffi.Char> path,
  ) {
    return _spine_skeleton_data_load_json(
      atlas,
      skeletonData,
      path,
    );
  }

  late final _spine_skeleton_data_load_jsonPtr = _lookup<
      ffi.NativeFunction<
          spine_skeleton_data_result Function(
              spine_atlas, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>>('spine_skeleton_data_load_json');
  late final _spine_skeleton_data_load_json = _spine_skeleton_data_load_jsonPtr
      .asFunction<spine_skeleton_data_result Function(spine_atlas, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();

  spine_skeleton_data_result spine_skeleton_data_load_binary(
    spine_atlas atlas,
    ffi.Pointer<ffi.Uint8> skeletonData,
    int length,
    ffi.Pointer<ffi.Char> path,
  ) {
    return _spine_skeleton_data_load_binary(
      atlas,
      skeletonData,
      length,
      path,
    );
  }

  late final _spine_skeleton_data_load_binaryPtr = _lookup<
      ffi.NativeFunction<
          spine_skeleton_data_result Function(spine_atlas, ffi.Pointer<ffi.Uint8>, ffi.Int32,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_data_load_binary');
  late final _spine_skeleton_data_load_binary = _spine_skeleton_data_load_binaryPtr.asFunction<
      spine_skeleton_data_result Function(spine_atlas, ffi.Pointer<ffi.Uint8>, int, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> spine_skeleton_data_result_get_error(
    spine_skeleton_data_result result,
  ) {
    return _spine_skeleton_data_result_get_error(
      result,
    );
  }

  late final _spine_skeleton_data_result_get_errorPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data_result)>>(
          'spine_skeleton_data_result_get_error');
  late final _spine_skeleton_data_result_get_error =
      _spine_skeleton_data_result_get_errorPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data_result)>();

  spine_skeleton_data spine_skeleton_data_result_get_data(
    spine_skeleton_data_result result,
  ) {
    return _spine_skeleton_data_result_get_data(
      result,
    );
  }

  late final _spine_skeleton_data_result_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_data Function(spine_skeleton_data_result)>>(
          'spine_skeleton_data_result_get_data');
  late final _spine_skeleton_data_result_get_data =
      _spine_skeleton_data_result_get_dataPtr.asFunction<spine_skeleton_data Function(spine_skeleton_data_result)>();

  void spine_skeleton_data_result_dispose(
    spine_skeleton_data_result result,
  ) {
    return _spine_skeleton_data_result_dispose(
      result,
    );
  }

  late final _spine_skeleton_data_result_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data_result)>>('spine_skeleton_data_result_dispose');
  late final _spine_skeleton_data_result_dispose =
      _spine_skeleton_data_result_disposePtr.asFunction<void Function(spine_skeleton_data_result)>();

  /// Skeleton drawable functionsp
  spine_skeleton_drawable spine_skeleton_drawable_create(
    spine_skeleton_data skeletonData,
  ) {
    return _spine_skeleton_drawable_create(
      skeletonData,
    );
  }

  late final _spine_skeleton_drawable_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_drawable Function(spine_skeleton_data)>>(
          'spine_skeleton_drawable_create');
  late final _spine_skeleton_drawable_create =
      _spine_skeleton_drawable_createPtr.asFunction<spine_skeleton_drawable Function(spine_skeleton_data)>();

  void spine_skeleton_drawable_update(
    spine_skeleton_drawable drawable,
    double delta,
  ) {
    return _spine_skeleton_drawable_update(
      drawable,
      delta,
    );
  }

  late final _spine_skeleton_drawable_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_drawable, ffi.Float)>>(
          'spine_skeleton_drawable_update');
  late final _spine_skeleton_drawable_update =
      _spine_skeleton_drawable_updatePtr.asFunction<void Function(spine_skeleton_drawable, double)>();

  spine_render_command spine_skeleton_drawable_render(
    spine_skeleton_drawable drawable,
  ) {
    return _spine_skeleton_drawable_render(
      drawable,
    );
  }

  late final _spine_skeleton_drawable_renderPtr =
      _lookup<ffi.NativeFunction<spine_render_command Function(spine_skeleton_drawable)>>(
          'spine_skeleton_drawable_render');
  late final _spine_skeleton_drawable_render =
      _spine_skeleton_drawable_renderPtr.asFunction<spine_render_command Function(spine_skeleton_drawable)>();

  void spine_skeleton_drawable_dispose(
    spine_skeleton_drawable drawable,
  ) {
    return _spine_skeleton_drawable_dispose(
      drawable,
    );
  }

  late final _spine_skeleton_drawable_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_drawable)>>('spine_skeleton_drawable_dispose');
  late final _spine_skeleton_drawable_dispose =
      _spine_skeleton_drawable_disposePtr.asFunction<void Function(spine_skeleton_drawable)>();

  spine_skeleton spine_skeleton_drawable_get_skeleton(
    spine_skeleton_drawable drawable,
  ) {
    return _spine_skeleton_drawable_get_skeleton(
      drawable,
    );
  }

  late final _spine_skeleton_drawable_get_skeletonPtr =
      _lookup<ffi.NativeFunction<spine_skeleton Function(spine_skeleton_drawable)>>(
          'spine_skeleton_drawable_get_skeleton');
  late final _spine_skeleton_drawable_get_skeleton =
      _spine_skeleton_drawable_get_skeletonPtr.asFunction<spine_skeleton Function(spine_skeleton_drawable)>();

  spine_animation_state spine_skeleton_drawable_get_animation_state(
    spine_skeleton_drawable drawable,
  ) {
    return _spine_skeleton_drawable_get_animation_state(
      drawable,
    );
  }

  late final _spine_skeleton_drawable_get_animation_statePtr =
      _lookup<ffi.NativeFunction<spine_animation_state Function(spine_skeleton_drawable)>>(
          'spine_skeleton_drawable_get_animation_state');
  late final _spine_skeleton_drawable_get_animation_state = _spine_skeleton_drawable_get_animation_statePtr
      .asFunction<spine_animation_state Function(spine_skeleton_drawable)>();

  spine_animation_state_data spine_skeleton_drawable_get_animation_state_data(
    spine_skeleton_drawable drawable,
  ) {
    return _spine_skeleton_drawable_get_animation_state_data(
      drawable,
    );
  }

  late final _spine_skeleton_drawable_get_animation_state_dataPtr =
      _lookup<ffi.NativeFunction<spine_animation_state_data Function(spine_skeleton_drawable)>>(
          'spine_skeleton_drawable_get_animation_state_data');
  late final _spine_skeleton_drawable_get_animation_state_data = _spine_skeleton_drawable_get_animation_state_dataPtr
      .asFunction<spine_animation_state_data Function(spine_skeleton_drawable)>();

  spine_animation_state_events spine_skeleton_drawable_get_animation_state_events(
    spine_skeleton_drawable drawable,
  ) {
    return _spine_skeleton_drawable_get_animation_state_events(
      drawable,
    );
  }

  late final _spine_skeleton_drawable_get_animation_state_eventsPtr =
      _lookup<ffi.NativeFunction<spine_animation_state_events Function(spine_skeleton_drawable)>>(
          'spine_skeleton_drawable_get_animation_state_events');
  late final _spine_skeleton_drawable_get_animation_state_events =
      _spine_skeleton_drawable_get_animation_state_eventsPtr
          .asFunction<spine_animation_state_events Function(spine_skeleton_drawable)>();

  /// Animation state events functions
  int spine_animation_state_events_get_num_events(
    spine_animation_state_events events,
  ) {
    return _spine_animation_state_events_get_num_events(
      events,
    );
  }

  late final _spine_animation_state_events_get_num_eventsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_animation_state_events)>>(
          'spine_animation_state_events_get_num_events');
  late final _spine_animation_state_events_get_num_events =
      _spine_animation_state_events_get_num_eventsPtr.asFunction<int Function(spine_animation_state_events)>();

  int spine_animation_state_events_get_event_type(
    spine_animation_state_events events,
    int index,
  ) {
    return _spine_animation_state_events_get_event_type(
      events,
      index,
    );
  }

  late final _spine_animation_state_events_get_event_typePtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_animation_state_events, ffi.Int32)>>(
          'spine_animation_state_events_get_event_type');
  late final _spine_animation_state_events_get_event_type =
      _spine_animation_state_events_get_event_typePtr.asFunction<int Function(spine_animation_state_events, int)>();

  spine_track_entry spine_animation_state_events_get_track_entry(
    spine_animation_state_events events,
    int index,
  ) {
    return _spine_animation_state_events_get_track_entry(
      events,
      index,
    );
  }

  late final _spine_animation_state_events_get_track_entryPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function(spine_animation_state_events, ffi.Int32)>>(
          'spine_animation_state_events_get_track_entry');
  late final _spine_animation_state_events_get_track_entry = _spine_animation_state_events_get_track_entryPtr
      .asFunction<spine_track_entry Function(spine_animation_state_events, int)>();

  spine_event spine_animation_state_events_get_event(
    spine_animation_state_events events,
    int index,
  ) {
    return _spine_animation_state_events_get_event(
      events,
      index,
    );
  }

  late final _spine_animation_state_events_get_eventPtr =
      _lookup<ffi.NativeFunction<spine_event Function(spine_animation_state_events, ffi.Int32)>>(
          'spine_animation_state_events_get_event');
  late final _spine_animation_state_events_get_event =
      _spine_animation_state_events_get_eventPtr.asFunction<spine_event Function(spine_animation_state_events, int)>();

  void spine_animation_state_events_reset(
    spine_animation_state_events events,
  ) {
    return _spine_animation_state_events_reset(
      events,
    );
  }

  late final _spine_animation_state_events_resetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state_events)>>(
          'spine_animation_state_events_reset');
  late final _spine_animation_state_events_reset =
      _spine_animation_state_events_resetPtr.asFunction<void Function(spine_animation_state_events)>();

  /// Skin functions
  spine_skin_entries spine_skin_get_entries(
    spine_skin skin,
  ) {
    return _spine_skin_get_entries(
      skin,
    );
  }

  late final _spine_skin_get_entriesPtr =
      _lookup<ffi.NativeFunction<spine_skin_entries Function(spine_skin)>>('spine_skin_get_entries');
  late final _spine_skin_get_entries = _spine_skin_get_entriesPtr.asFunction<spine_skin_entries Function(spine_skin)>();

  /// Skin entries functions
  void spine_skin_entries_dispose(
    spine_skin_entries entries,
  ) {
    return _spine_skin_entries_dispose(
      entries,
    );
  }

  late final _spine_skin_entries_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin_entries)>>('spine_skin_entries_dispose');
  late final _spine_skin_entries_dispose =
      _spine_skin_entries_disposePtr.asFunction<void Function(spine_skin_entries)>();

  int spine_skin_entries_get_num_entries(
    spine_skin_entries entries,
  ) {
    return _spine_skin_entries_get_num_entries(
      entries,
    );
  }

  late final _spine_skin_entries_get_num_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skin_entries)>>('spine_skin_entries_get_num_entries');
  late final _spine_skin_entries_get_num_entries =
      _spine_skin_entries_get_num_entriesPtr.asFunction<int Function(spine_skin_entries)>();

  spine_skin_entry spine_skin_entries_get_entry(
    spine_skin_entries entries,
    int index,
  ) {
    return _spine_skin_entries_get_entry(
      entries,
      index,
    );
  }

  late final _spine_skin_entries_get_entryPtr =
      _lookup<ffi.NativeFunction<spine_skin_entry Function(spine_skin_entries, ffi.Int32)>>(
          'spine_skin_entries_get_entry');
  late final _spine_skin_entries_get_entry =
      _spine_skin_entries_get_entryPtr.asFunction<spine_skin_entry Function(spine_skin_entries, int)>();

  /// Skin entry functions
  int spine_skin_entry_get_slot_index(
    spine_skin_entry entry,
  ) {
    return _spine_skin_entry_get_slot_index(
      entry,
    );
  }

  late final _spine_skin_entry_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skin_entry)>>('spine_skin_entry_get_slot_index');
  late final _spine_skin_entry_get_slot_index =
      _spine_skin_entry_get_slot_indexPtr.asFunction<int Function(spine_skin_entry)>();

  ffi.Pointer<ffi.Char> spine_skin_entry_get_name(
    spine_skin_entry entry,
  ) {
    return _spine_skin_entry_get_name(
      entry,
    );
  }

  late final _spine_skin_entry_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skin_entry)>>('spine_skin_entry_get_name');
  late final _spine_skin_entry_get_name =
      _spine_skin_entry_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_skin_entry)>();

  spine_attachment spine_skin_entry_get_attachment(
    spine_skin_entry entry,
  ) {
    return _spine_skin_entry_get_attachment(
      entry,
    );
  }

  late final _spine_skin_entry_get_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_skin_entry)>>('spine_skin_entry_get_attachment');
  late final _spine_skin_entry_get_attachment =
      _spine_skin_entry_get_attachmentPtr.asFunction<spine_attachment Function(spine_skin_entry)>();

  /// Skeleton functions
  void spine_skeleton_get_bounds(
    spine_skeleton skeleton,
    spine_array_float output,
  ) {
    return _spine_skeleton_get_bounds(
      skeleton,
      output,
    );
  }

  late final _spine_skeleton_get_boundsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_array_float)>>('spine_skeleton_get_bounds');
  late final _spine_skeleton_get_bounds =
      _spine_skeleton_get_boundsPtr.asFunction<void Function(spine_skeleton, spine_array_float)>();

  void spine_skeleton_get_position_v(
    spine_skeleton skeleton,
    spine_array_float output,
  ) {
    return _spine_skeleton_get_position_v(
      skeleton,
      output,
    );
  }

  late final _spine_skeleton_get_position_vPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_array_float)>>(
          'spine_skeleton_get_position_v');
  late final _spine_skeleton_get_position_v =
      _spine_skeleton_get_position_vPtr.asFunction<void Function(spine_skeleton, spine_array_float)>();

  /// BonePose functions
  void spine_bone_pose_world_to_local_v(
    spine_bone_pose self,
    double world_x,
    double world_y,
    spine_array_float output,
  ) {
    return _spine_bone_pose_world_to_local_v(
      self,
      world_x,
      world_y,
      output,
    );
  }

  late final _spine_bone_pose_world_to_local_vPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float, ffi.Float, spine_array_float)>>(
          'spine_bone_pose_world_to_local_v');
  late final _spine_bone_pose_world_to_local_v = _spine_bone_pose_world_to_local_vPtr
      .asFunction<void Function(spine_bone_pose, double, double, spine_array_float)>();

  void spine_bone_pose_local_to_world_v(
    spine_bone_pose self,
    double local_x,
    double local_y,
    spine_array_float output,
  ) {
    return _spine_bone_pose_local_to_world_v(
      self,
      local_x,
      local_y,
      output,
    );
  }

  late final _spine_bone_pose_local_to_world_vPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float, ffi.Float, spine_array_float)>>(
          'spine_bone_pose_local_to_world_v');
  late final _spine_bone_pose_local_to_world_v = _spine_bone_pose_local_to_world_vPtr
      .asFunction<void Function(spine_bone_pose, double, double, spine_array_float)>();

  void spine_bone_pose_world_to_parent_v(
    spine_bone_pose self,
    double world_x,
    double world_y,
    spine_array_float output,
  ) {
    return _spine_bone_pose_world_to_parent_v(
      self,
      world_x,
      world_y,
      output,
    );
  }

  late final _spine_bone_pose_world_to_parent_vPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float, ffi.Float, spine_array_float)>>(
          'spine_bone_pose_world_to_parent_v');
  late final _spine_bone_pose_world_to_parent_v = _spine_bone_pose_world_to_parent_vPtr
      .asFunction<void Function(spine_bone_pose, double, double, spine_array_float)>();

  void spine_bone_pose_parent_to_world_v(
    spine_bone_pose self,
    double parent_x,
    double parent_y,
    spine_array_float output,
  ) {
    return _spine_bone_pose_parent_to_world_v(
      self,
      parent_x,
      parent_y,
      output,
    );
  }

  late final _spine_bone_pose_parent_to_world_vPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float, ffi.Float, spine_array_float)>>(
          'spine_bone_pose_parent_to_world_v');
  late final _spine_bone_pose_parent_to_world_v = _spine_bone_pose_parent_to_world_vPtr
      .asFunction<void Function(spine_bone_pose, double, double, spine_array_float)>();

  void spine_animation_state_set_listener(
    spine_animation_state state,
    spine_animation_state_listener listener,
    ffi.Pointer<ffi.Void> user_data,
  ) {
    return _spine_animation_state_set_listener(
      state,
      listener,
      user_data,
    );
  }

  late final _spine_animation_state_set_listenerPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_animation_state, spine_animation_state_listener,
              ffi.Pointer<ffi.Void>)>>('spine_animation_state_set_listener');
  late final _spine_animation_state_set_listener = _spine_animation_state_set_listenerPtr
      .asFunction<void Function(spine_animation_state, spine_animation_state_listener, ffi.Pointer<ffi.Void>)>();

  void spine_track_entry_set_listener(
    spine_track_entry entry,
    spine_animation_state_listener listener,
    ffi.Pointer<ffi.Void> user_data,
  ) {
    return _spine_track_entry_set_listener(
      entry,
      listener,
      user_data,
    );
  }

  late final _spine_track_entry_set_listenerPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_track_entry, spine_animation_state_listener, ffi.Pointer<ffi.Void>)>>(
      'spine_track_entry_set_listener');
  late final _spine_track_entry_set_listener = _spine_track_entry_set_listenerPtr
      .asFunction<void Function(spine_track_entry, spine_animation_state_listener, ffi.Pointer<ffi.Void>)>();

  /// Upcast functions (derived to base) - always safe
  spine_curve_timeline1 spine_alpha_timeline_cast_to_curve_timeline1(
    spine_alpha_timeline obj,
  ) {
    return _spine_alpha_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_alpha_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_alpha_timeline)>>(
          'spine_alpha_timeline_cast_to_curve_timeline1');
  late final _spine_alpha_timeline_cast_to_curve_timeline1 = _spine_alpha_timeline_cast_to_curve_timeline1Ptr
      .asFunction<spine_curve_timeline1 Function(spine_alpha_timeline)>();

  spine_curve_timeline spine_alpha_timeline_cast_to_curve_timeline(
    spine_alpha_timeline obj,
  ) {
    return _spine_alpha_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_alpha_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_alpha_timeline)>>(
          'spine_alpha_timeline_cast_to_curve_timeline');
  late final _spine_alpha_timeline_cast_to_curve_timeline =
      _spine_alpha_timeline_cast_to_curve_timelinePtr.asFunction<spine_curve_timeline Function(spine_alpha_timeline)>();

  spine_timeline spine_alpha_timeline_cast_to_timeline(
    spine_alpha_timeline obj,
  ) {
    return _spine_alpha_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_alpha_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_alpha_timeline)>>(
          'spine_alpha_timeline_cast_to_timeline');
  late final _spine_alpha_timeline_cast_to_timeline =
      _spine_alpha_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_alpha_timeline)>();

  spine_slot_timeline spine_alpha_timeline_cast_to_slot_timeline(
    spine_alpha_timeline obj,
  ) {
    return _spine_alpha_timeline_cast_to_slot_timeline(
      obj,
    );
  }

  late final _spine_alpha_timeline_cast_to_slot_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_timeline Function(spine_alpha_timeline)>>(
          'spine_alpha_timeline_cast_to_slot_timeline');
  late final _spine_alpha_timeline_cast_to_slot_timeline =
      _spine_alpha_timeline_cast_to_slot_timelinePtr.asFunction<spine_slot_timeline Function(spine_alpha_timeline)>();

  spine_attachment_loader spine_atlas_attachment_loader_cast_to_attachment_loader(
    spine_atlas_attachment_loader obj,
  ) {
    return _spine_atlas_attachment_loader_cast_to_attachment_loader(
      obj,
    );
  }

  late final _spine_atlas_attachment_loader_cast_to_attachment_loaderPtr =
      _lookup<ffi.NativeFunction<spine_attachment_loader Function(spine_atlas_attachment_loader)>>(
          'spine_atlas_attachment_loader_cast_to_attachment_loader');
  late final _spine_atlas_attachment_loader_cast_to_attachment_loader =
      _spine_atlas_attachment_loader_cast_to_attachment_loaderPtr
          .asFunction<spine_attachment_loader Function(spine_atlas_attachment_loader)>();

  spine_texture_region spine_atlas_region_cast_to_texture_region(
    spine_atlas_region obj,
  ) {
    return _spine_atlas_region_cast_to_texture_region(
      obj,
    );
  }

  late final _spine_atlas_region_cast_to_texture_regionPtr =
      _lookup<ffi.NativeFunction<spine_texture_region Function(spine_atlas_region)>>(
          'spine_atlas_region_cast_to_texture_region');
  late final _spine_atlas_region_cast_to_texture_region =
      _spine_atlas_region_cast_to_texture_regionPtr.asFunction<spine_texture_region Function(spine_atlas_region)>();

  spine_timeline spine_attachment_timeline_cast_to_timeline(
    spine_attachment_timeline obj,
  ) {
    return _spine_attachment_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_attachment_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_attachment_timeline)>>(
          'spine_attachment_timeline_cast_to_timeline');
  late final _spine_attachment_timeline_cast_to_timeline =
      _spine_attachment_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_attachment_timeline)>();

  spine_slot_timeline spine_attachment_timeline_cast_to_slot_timeline(
    spine_attachment_timeline obj,
  ) {
    return _spine_attachment_timeline_cast_to_slot_timeline(
      obj,
    );
  }

  late final _spine_attachment_timeline_cast_to_slot_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_timeline Function(spine_attachment_timeline)>>(
          'spine_attachment_timeline_cast_to_slot_timeline');
  late final _spine_attachment_timeline_cast_to_slot_timeline = _spine_attachment_timeline_cast_to_slot_timelinePtr
      .asFunction<spine_slot_timeline Function(spine_attachment_timeline)>();

  spine_posed spine_bone_cast_to_posed(
    spine_bone obj,
  ) {
    return _spine_bone_cast_to_posed(
      obj,
    );
  }

  late final _spine_bone_cast_to_posedPtr =
      _lookup<ffi.NativeFunction<spine_posed Function(spine_bone)>>('spine_bone_cast_to_posed');
  late final _spine_bone_cast_to_posed = _spine_bone_cast_to_posedPtr.asFunction<spine_posed Function(spine_bone)>();

  spine_posed_active spine_bone_cast_to_posed_active(
    spine_bone obj,
  ) {
    return _spine_bone_cast_to_posed_active(
      obj,
    );
  }

  late final _spine_bone_cast_to_posed_activePtr =
      _lookup<ffi.NativeFunction<spine_posed_active Function(spine_bone)>>('spine_bone_cast_to_posed_active');
  late final _spine_bone_cast_to_posed_active =
      _spine_bone_cast_to_posed_activePtr.asFunction<spine_posed_active Function(spine_bone)>();

  spine_update spine_bone_cast_to_update(
    spine_bone obj,
  ) {
    return _spine_bone_cast_to_update(
      obj,
    );
  }

  late final _spine_bone_cast_to_updatePtr =
      _lookup<ffi.NativeFunction<spine_update Function(spine_bone)>>('spine_bone_cast_to_update');
  late final _spine_bone_cast_to_update = _spine_bone_cast_to_updatePtr.asFunction<spine_update Function(spine_bone)>();

  spine_posed_data spine_bone_data_cast_to_posed_data(
    spine_bone_data obj,
  ) {
    return _spine_bone_data_cast_to_posed_data(
      obj,
    );
  }

  late final _spine_bone_data_cast_to_posed_dataPtr =
      _lookup<ffi.NativeFunction<spine_posed_data Function(spine_bone_data)>>('spine_bone_data_cast_to_posed_data');
  late final _spine_bone_data_cast_to_posed_data =
      _spine_bone_data_cast_to_posed_dataPtr.asFunction<spine_posed_data Function(spine_bone_data)>();

  spine_bone_local spine_bone_pose_cast_to_bone_local(
    spine_bone_pose obj,
  ) {
    return _spine_bone_pose_cast_to_bone_local(
      obj,
    );
  }

  late final _spine_bone_pose_cast_to_bone_localPtr =
      _lookup<ffi.NativeFunction<spine_bone_local Function(spine_bone_pose)>>('spine_bone_pose_cast_to_bone_local');
  late final _spine_bone_pose_cast_to_bone_local =
      _spine_bone_pose_cast_to_bone_localPtr.asFunction<spine_bone_local Function(spine_bone_pose)>();

  spine_update spine_bone_pose_cast_to_update(
    spine_bone_pose obj,
  ) {
    return _spine_bone_pose_cast_to_update(
      obj,
    );
  }

  late final _spine_bone_pose_cast_to_updatePtr =
      _lookup<ffi.NativeFunction<spine_update Function(spine_bone_pose)>>('spine_bone_pose_cast_to_update');
  late final _spine_bone_pose_cast_to_update =
      _spine_bone_pose_cast_to_updatePtr.asFunction<spine_update Function(spine_bone_pose)>();

  spine_curve_timeline1 spine_bone_timeline1_cast_to_curve_timeline1(
    spine_bone_timeline1 obj,
  ) {
    return _spine_bone_timeline1_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_bone_timeline1_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_cast_to_curve_timeline1');
  late final _spine_bone_timeline1_cast_to_curve_timeline1 = _spine_bone_timeline1_cast_to_curve_timeline1Ptr
      .asFunction<spine_curve_timeline1 Function(spine_bone_timeline1)>();

  spine_curve_timeline spine_bone_timeline1_cast_to_curve_timeline(
    spine_bone_timeline1 obj,
  ) {
    return _spine_bone_timeline1_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline1_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_cast_to_curve_timeline');
  late final _spine_bone_timeline1_cast_to_curve_timeline =
      _spine_bone_timeline1_cast_to_curve_timelinePtr.asFunction<spine_curve_timeline Function(spine_bone_timeline1)>();

  spine_timeline spine_bone_timeline1_cast_to_timeline(
    spine_bone_timeline1 obj,
  ) {
    return _spine_bone_timeline1_cast_to_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline1_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_cast_to_timeline');
  late final _spine_bone_timeline1_cast_to_timeline =
      _spine_bone_timeline1_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_bone_timeline1)>();

  spine_bone_timeline spine_bone_timeline1_cast_to_bone_timeline(
    spine_bone_timeline1 obj,
  ) {
    return _spine_bone_timeline1_cast_to_bone_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline1_cast_to_bone_timelinePtr =
      _lookup<ffi.NativeFunction<spine_bone_timeline Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_cast_to_bone_timeline');
  late final _spine_bone_timeline1_cast_to_bone_timeline =
      _spine_bone_timeline1_cast_to_bone_timelinePtr.asFunction<spine_bone_timeline Function(spine_bone_timeline1)>();

  spine_curve_timeline spine_bone_timeline2_cast_to_curve_timeline(
    spine_bone_timeline2 obj,
  ) {
    return _spine_bone_timeline2_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline2_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_bone_timeline2)>>(
          'spine_bone_timeline2_cast_to_curve_timeline');
  late final _spine_bone_timeline2_cast_to_curve_timeline =
      _spine_bone_timeline2_cast_to_curve_timelinePtr.asFunction<spine_curve_timeline Function(spine_bone_timeline2)>();

  spine_timeline spine_bone_timeline2_cast_to_timeline(
    spine_bone_timeline2 obj,
  ) {
    return _spine_bone_timeline2_cast_to_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline2_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_bone_timeline2)>>(
          'spine_bone_timeline2_cast_to_timeline');
  late final _spine_bone_timeline2_cast_to_timeline =
      _spine_bone_timeline2_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_bone_timeline2)>();

  spine_bone_timeline spine_bone_timeline2_cast_to_bone_timeline(
    spine_bone_timeline2 obj,
  ) {
    return _spine_bone_timeline2_cast_to_bone_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline2_cast_to_bone_timelinePtr =
      _lookup<ffi.NativeFunction<spine_bone_timeline Function(spine_bone_timeline2)>>(
          'spine_bone_timeline2_cast_to_bone_timeline');
  late final _spine_bone_timeline2_cast_to_bone_timeline =
      _spine_bone_timeline2_cast_to_bone_timelinePtr.asFunction<spine_bone_timeline Function(spine_bone_timeline2)>();

  spine_vertex_attachment spine_bounding_box_attachment_cast_to_vertex_attachment(
    spine_bounding_box_attachment obj,
  ) {
    return _spine_bounding_box_attachment_cast_to_vertex_attachment(
      obj,
    );
  }

  late final _spine_bounding_box_attachment_cast_to_vertex_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_vertex_attachment Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_cast_to_vertex_attachment');
  late final _spine_bounding_box_attachment_cast_to_vertex_attachment =
      _spine_bounding_box_attachment_cast_to_vertex_attachmentPtr
          .asFunction<spine_vertex_attachment Function(spine_bounding_box_attachment)>();

  spine_attachment spine_bounding_box_attachment_cast_to_attachment(
    spine_bounding_box_attachment obj,
  ) {
    return _spine_bounding_box_attachment_cast_to_attachment(
      obj,
    );
  }

  late final _spine_bounding_box_attachment_cast_to_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_cast_to_attachment');
  late final _spine_bounding_box_attachment_cast_to_attachment = _spine_bounding_box_attachment_cast_to_attachmentPtr
      .asFunction<spine_attachment Function(spine_bounding_box_attachment)>();

  spine_vertex_attachment spine_clipping_attachment_cast_to_vertex_attachment(
    spine_clipping_attachment obj,
  ) {
    return _spine_clipping_attachment_cast_to_vertex_attachment(
      obj,
    );
  }

  late final _spine_clipping_attachment_cast_to_vertex_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_vertex_attachment Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_cast_to_vertex_attachment');
  late final _spine_clipping_attachment_cast_to_vertex_attachment =
      _spine_clipping_attachment_cast_to_vertex_attachmentPtr
          .asFunction<spine_vertex_attachment Function(spine_clipping_attachment)>();

  spine_attachment spine_clipping_attachment_cast_to_attachment(
    spine_clipping_attachment obj,
  ) {
    return _spine_clipping_attachment_cast_to_attachment(
      obj,
    );
  }

  late final _spine_clipping_attachment_cast_to_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_cast_to_attachment');
  late final _spine_clipping_attachment_cast_to_attachment = _spine_clipping_attachment_cast_to_attachmentPtr
      .asFunction<spine_attachment Function(spine_clipping_attachment)>();

  spine_update spine_constraint_cast_to_update(
    spine_constraint obj,
  ) {
    return _spine_constraint_cast_to_update(
      obj,
    );
  }

  late final _spine_constraint_cast_to_updatePtr =
      _lookup<ffi.NativeFunction<spine_update Function(spine_constraint)>>('spine_constraint_cast_to_update');
  late final _spine_constraint_cast_to_update =
      _spine_constraint_cast_to_updatePtr.asFunction<spine_update Function(spine_constraint)>();

  spine_curve_timeline1 spine_constraint_timeline1_cast_to_curve_timeline1(
    spine_constraint_timeline1 obj,
  ) {
    return _spine_constraint_timeline1_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_constraint_timeline1_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_cast_to_curve_timeline1');
  late final _spine_constraint_timeline1_cast_to_curve_timeline1 =
      _spine_constraint_timeline1_cast_to_curve_timeline1Ptr
          .asFunction<spine_curve_timeline1 Function(spine_constraint_timeline1)>();

  spine_curve_timeline spine_constraint_timeline1_cast_to_curve_timeline(
    spine_constraint_timeline1 obj,
  ) {
    return _spine_constraint_timeline1_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline1_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_cast_to_curve_timeline');
  late final _spine_constraint_timeline1_cast_to_curve_timeline = _spine_constraint_timeline1_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_constraint_timeline1)>();

  spine_timeline spine_constraint_timeline1_cast_to_timeline(
    spine_constraint_timeline1 obj,
  ) {
    return _spine_constraint_timeline1_cast_to_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline1_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_cast_to_timeline');
  late final _spine_constraint_timeline1_cast_to_timeline =
      _spine_constraint_timeline1_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_constraint_timeline1)>();

  spine_constraint_timeline spine_constraint_timeline1_cast_to_constraint_timeline(
    spine_constraint_timeline1 obj,
  ) {
    return _spine_constraint_timeline1_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline1_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_cast_to_constraint_timeline');
  late final _spine_constraint_timeline1_cast_to_constraint_timeline =
      _spine_constraint_timeline1_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_constraint_timeline1)>();

  spine_timeline spine_curve_timeline_cast_to_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_timeline');
  late final _spine_curve_timeline_cast_to_timeline =
      _spine_curve_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_curve_timeline)>();

  spine_curve_timeline spine_curve_timeline1_cast_to_curve_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_curve_timeline');
  late final _spine_curve_timeline1_cast_to_curve_timeline = _spine_curve_timeline1_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_curve_timeline1)>();

  spine_timeline spine_curve_timeline1_cast_to_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_timeline');
  late final _spine_curve_timeline1_cast_to_timeline =
      _spine_curve_timeline1_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_curve_timeline1)>();

  spine_slot_curve_timeline spine_deform_timeline_cast_to_slot_curve_timeline(
    spine_deform_timeline obj,
  ) {
    return _spine_deform_timeline_cast_to_slot_curve_timeline(
      obj,
    );
  }

  late final _spine_deform_timeline_cast_to_slot_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_curve_timeline Function(spine_deform_timeline)>>(
          'spine_deform_timeline_cast_to_slot_curve_timeline');
  late final _spine_deform_timeline_cast_to_slot_curve_timeline = _spine_deform_timeline_cast_to_slot_curve_timelinePtr
      .asFunction<spine_slot_curve_timeline Function(spine_deform_timeline)>();

  spine_curve_timeline spine_deform_timeline_cast_to_curve_timeline(
    spine_deform_timeline obj,
  ) {
    return _spine_deform_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_deform_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_deform_timeline)>>(
          'spine_deform_timeline_cast_to_curve_timeline');
  late final _spine_deform_timeline_cast_to_curve_timeline = _spine_deform_timeline_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_deform_timeline)>();

  spine_timeline spine_deform_timeline_cast_to_timeline(
    spine_deform_timeline obj,
  ) {
    return _spine_deform_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_deform_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_deform_timeline)>>(
          'spine_deform_timeline_cast_to_timeline');
  late final _spine_deform_timeline_cast_to_timeline =
      _spine_deform_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_deform_timeline)>();

  spine_slot_timeline spine_deform_timeline_cast_to_slot_timeline(
    spine_deform_timeline obj,
  ) {
    return _spine_deform_timeline_cast_to_slot_timeline(
      obj,
    );
  }

  late final _spine_deform_timeline_cast_to_slot_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_timeline Function(spine_deform_timeline)>>(
          'spine_deform_timeline_cast_to_slot_timeline');
  late final _spine_deform_timeline_cast_to_slot_timeline =
      _spine_deform_timeline_cast_to_slot_timelinePtr.asFunction<spine_slot_timeline Function(spine_deform_timeline)>();

  spine_timeline spine_draw_order_timeline_cast_to_timeline(
    spine_draw_order_timeline obj,
  ) {
    return _spine_draw_order_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_draw_order_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_draw_order_timeline)>>(
          'spine_draw_order_timeline_cast_to_timeline');
  late final _spine_draw_order_timeline_cast_to_timeline =
      _spine_draw_order_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_draw_order_timeline)>();

  spine_timeline spine_event_timeline_cast_to_timeline(
    spine_event_timeline obj,
  ) {
    return _spine_event_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_event_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_event_timeline)>>(
          'spine_event_timeline_cast_to_timeline');
  late final _spine_event_timeline_cast_to_timeline =
      _spine_event_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_event_timeline)>();

  spine_from_property spine_from_rotate_cast_to_from_property(
    spine_from_rotate obj,
  ) {
    return _spine_from_rotate_cast_to_from_property(
      obj,
    );
  }

  late final _spine_from_rotate_cast_to_from_propertyPtr =
      _lookup<ffi.NativeFunction<spine_from_property Function(spine_from_rotate)>>(
          'spine_from_rotate_cast_to_from_property');
  late final _spine_from_rotate_cast_to_from_property =
      _spine_from_rotate_cast_to_from_propertyPtr.asFunction<spine_from_property Function(spine_from_rotate)>();

  spine_from_property spine_from_scale_x_cast_to_from_property(
    spine_from_scale_x obj,
  ) {
    return _spine_from_scale_x_cast_to_from_property(
      obj,
    );
  }

  late final _spine_from_scale_x_cast_to_from_propertyPtr =
      _lookup<ffi.NativeFunction<spine_from_property Function(spine_from_scale_x)>>(
          'spine_from_scale_x_cast_to_from_property');
  late final _spine_from_scale_x_cast_to_from_property =
      _spine_from_scale_x_cast_to_from_propertyPtr.asFunction<spine_from_property Function(spine_from_scale_x)>();

  spine_from_property spine_from_scale_y_cast_to_from_property(
    spine_from_scale_y obj,
  ) {
    return _spine_from_scale_y_cast_to_from_property(
      obj,
    );
  }

  late final _spine_from_scale_y_cast_to_from_propertyPtr =
      _lookup<ffi.NativeFunction<spine_from_property Function(spine_from_scale_y)>>(
          'spine_from_scale_y_cast_to_from_property');
  late final _spine_from_scale_y_cast_to_from_property =
      _spine_from_scale_y_cast_to_from_propertyPtr.asFunction<spine_from_property Function(spine_from_scale_y)>();

  spine_from_property spine_from_shear_y_cast_to_from_property(
    spine_from_shear_y obj,
  ) {
    return _spine_from_shear_y_cast_to_from_property(
      obj,
    );
  }

  late final _spine_from_shear_y_cast_to_from_propertyPtr =
      _lookup<ffi.NativeFunction<spine_from_property Function(spine_from_shear_y)>>(
          'spine_from_shear_y_cast_to_from_property');
  late final _spine_from_shear_y_cast_to_from_property =
      _spine_from_shear_y_cast_to_from_propertyPtr.asFunction<spine_from_property Function(spine_from_shear_y)>();

  spine_from_property spine_from_x_cast_to_from_property(
    spine_from_x obj,
  ) {
    return _spine_from_x_cast_to_from_property(
      obj,
    );
  }

  late final _spine_from_x_cast_to_from_propertyPtr =
      _lookup<ffi.NativeFunction<spine_from_property Function(spine_from_x)>>('spine_from_x_cast_to_from_property');
  late final _spine_from_x_cast_to_from_property =
      _spine_from_x_cast_to_from_propertyPtr.asFunction<spine_from_property Function(spine_from_x)>();

  spine_from_property spine_from_y_cast_to_from_property(
    spine_from_y obj,
  ) {
    return _spine_from_y_cast_to_from_property(
      obj,
    );
  }

  late final _spine_from_y_cast_to_from_propertyPtr =
      _lookup<ffi.NativeFunction<spine_from_property Function(spine_from_y)>>('spine_from_y_cast_to_from_property');
  late final _spine_from_y_cast_to_from_property =
      _spine_from_y_cast_to_from_propertyPtr.asFunction<spine_from_property Function(spine_from_y)>();

  spine_ik_constraint_base spine_ik_constraint_cast_to_ik_constraint_base(
    spine_ik_constraint obj,
  ) {
    return _spine_ik_constraint_cast_to_ik_constraint_base(
      obj,
    );
  }

  late final _spine_ik_constraint_cast_to_ik_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_base Function(spine_ik_constraint)>>(
          'spine_ik_constraint_cast_to_ik_constraint_base');
  late final _spine_ik_constraint_cast_to_ik_constraint_base = _spine_ik_constraint_cast_to_ik_constraint_basePtr
      .asFunction<spine_ik_constraint_base Function(spine_ik_constraint)>();

  spine_posed spine_ik_constraint_cast_to_posed(
    spine_ik_constraint obj,
  ) {
    return _spine_ik_constraint_cast_to_posed(
      obj,
    );
  }

  late final _spine_ik_constraint_cast_to_posedPtr =
      _lookup<ffi.NativeFunction<spine_posed Function(spine_ik_constraint)>>('spine_ik_constraint_cast_to_posed');
  late final _spine_ik_constraint_cast_to_posed =
      _spine_ik_constraint_cast_to_posedPtr.asFunction<spine_posed Function(spine_ik_constraint)>();

  spine_posed_active spine_ik_constraint_cast_to_posed_active(
    spine_ik_constraint obj,
  ) {
    return _spine_ik_constraint_cast_to_posed_active(
      obj,
    );
  }

  late final _spine_ik_constraint_cast_to_posed_activePtr =
      _lookup<ffi.NativeFunction<spine_posed_active Function(spine_ik_constraint)>>(
          'spine_ik_constraint_cast_to_posed_active');
  late final _spine_ik_constraint_cast_to_posed_active =
      _spine_ik_constraint_cast_to_posed_activePtr.asFunction<spine_posed_active Function(spine_ik_constraint)>();

  spine_constraint spine_ik_constraint_cast_to_constraint(
    spine_ik_constraint obj,
  ) {
    return _spine_ik_constraint_cast_to_constraint(
      obj,
    );
  }

  late final _spine_ik_constraint_cast_to_constraintPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_ik_constraint)>>(
          'spine_ik_constraint_cast_to_constraint');
  late final _spine_ik_constraint_cast_to_constraint =
      _spine_ik_constraint_cast_to_constraintPtr.asFunction<spine_constraint Function(spine_ik_constraint)>();

  spine_update spine_ik_constraint_cast_to_update(
    spine_ik_constraint obj,
  ) {
    return _spine_ik_constraint_cast_to_update(
      obj,
    );
  }

  late final _spine_ik_constraint_cast_to_updatePtr =
      _lookup<ffi.NativeFunction<spine_update Function(spine_ik_constraint)>>('spine_ik_constraint_cast_to_update');
  late final _spine_ik_constraint_cast_to_update =
      _spine_ik_constraint_cast_to_updatePtr.asFunction<spine_update Function(spine_ik_constraint)>();

  spine_posed spine_ik_constraint_base_cast_to_posed(
    spine_ik_constraint_base obj,
  ) {
    return _spine_ik_constraint_base_cast_to_posed(
      obj,
    );
  }

  late final _spine_ik_constraint_base_cast_to_posedPtr =
      _lookup<ffi.NativeFunction<spine_posed Function(spine_ik_constraint_base)>>(
          'spine_ik_constraint_base_cast_to_posed');
  late final _spine_ik_constraint_base_cast_to_posed =
      _spine_ik_constraint_base_cast_to_posedPtr.asFunction<spine_posed Function(spine_ik_constraint_base)>();

  spine_posed_active spine_ik_constraint_base_cast_to_posed_active(
    spine_ik_constraint_base obj,
  ) {
    return _spine_ik_constraint_base_cast_to_posed_active(
      obj,
    );
  }

  late final _spine_ik_constraint_base_cast_to_posed_activePtr =
      _lookup<ffi.NativeFunction<spine_posed_active Function(spine_ik_constraint_base)>>(
          'spine_ik_constraint_base_cast_to_posed_active');
  late final _spine_ik_constraint_base_cast_to_posed_active = _spine_ik_constraint_base_cast_to_posed_activePtr
      .asFunction<spine_posed_active Function(spine_ik_constraint_base)>();

  spine_constraint spine_ik_constraint_base_cast_to_constraint(
    spine_ik_constraint_base obj,
  ) {
    return _spine_ik_constraint_base_cast_to_constraint(
      obj,
    );
  }

  late final _spine_ik_constraint_base_cast_to_constraintPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_ik_constraint_base)>>(
          'spine_ik_constraint_base_cast_to_constraint');
  late final _spine_ik_constraint_base_cast_to_constraint =
      _spine_ik_constraint_base_cast_to_constraintPtr.asFunction<spine_constraint Function(spine_ik_constraint_base)>();

  spine_update spine_ik_constraint_base_cast_to_update(
    spine_ik_constraint_base obj,
  ) {
    return _spine_ik_constraint_base_cast_to_update(
      obj,
    );
  }

  late final _spine_ik_constraint_base_cast_to_updatePtr =
      _lookup<ffi.NativeFunction<spine_update Function(spine_ik_constraint_base)>>(
          'spine_ik_constraint_base_cast_to_update');
  late final _spine_ik_constraint_base_cast_to_update =
      _spine_ik_constraint_base_cast_to_updatePtr.asFunction<spine_update Function(spine_ik_constraint_base)>();

  spine_posed_data spine_ik_constraint_data_cast_to_posed_data(
    spine_ik_constraint_data obj,
  ) {
    return _spine_ik_constraint_data_cast_to_posed_data(
      obj,
    );
  }

  late final _spine_ik_constraint_data_cast_to_posed_dataPtr =
      _lookup<ffi.NativeFunction<spine_posed_data Function(spine_ik_constraint_data)>>(
          'spine_ik_constraint_data_cast_to_posed_data');
  late final _spine_ik_constraint_data_cast_to_posed_data =
      _spine_ik_constraint_data_cast_to_posed_dataPtr.asFunction<spine_posed_data Function(spine_ik_constraint_data)>();

  spine_constraint_data spine_ik_constraint_data_cast_to_constraint_data(
    spine_ik_constraint_data obj,
  ) {
    return _spine_ik_constraint_data_cast_to_constraint_data(
      obj,
    );
  }

  late final _spine_ik_constraint_data_cast_to_constraint_dataPtr =
      _lookup<ffi.NativeFunction<spine_constraint_data Function(spine_ik_constraint_data)>>(
          'spine_ik_constraint_data_cast_to_constraint_data');
  late final _spine_ik_constraint_data_cast_to_constraint_data = _spine_ik_constraint_data_cast_to_constraint_dataPtr
      .asFunction<spine_constraint_data Function(spine_ik_constraint_data)>();

  spine_curve_timeline spine_ik_constraint_timeline_cast_to_curve_timeline(
    spine_ik_constraint_timeline obj,
  ) {
    return _spine_ik_constraint_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_ik_constraint_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_ik_constraint_timeline)>>(
          'spine_ik_constraint_timeline_cast_to_curve_timeline');
  late final _spine_ik_constraint_timeline_cast_to_curve_timeline =
      _spine_ik_constraint_timeline_cast_to_curve_timelinePtr
          .asFunction<spine_curve_timeline Function(spine_ik_constraint_timeline)>();

  spine_timeline spine_ik_constraint_timeline_cast_to_timeline(
    spine_ik_constraint_timeline obj,
  ) {
    return _spine_ik_constraint_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_ik_constraint_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_ik_constraint_timeline)>>(
          'spine_ik_constraint_timeline_cast_to_timeline');
  late final _spine_ik_constraint_timeline_cast_to_timeline = _spine_ik_constraint_timeline_cast_to_timelinePtr
      .asFunction<spine_timeline Function(spine_ik_constraint_timeline)>();

  spine_constraint_timeline spine_ik_constraint_timeline_cast_to_constraint_timeline(
    spine_ik_constraint_timeline obj,
  ) {
    return _spine_ik_constraint_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_ik_constraint_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_ik_constraint_timeline)>>(
          'spine_ik_constraint_timeline_cast_to_constraint_timeline');
  late final _spine_ik_constraint_timeline_cast_to_constraint_timeline =
      _spine_ik_constraint_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_ik_constraint_timeline)>();

  spine_timeline spine_inherit_timeline_cast_to_timeline(
    spine_inherit_timeline obj,
  ) {
    return _spine_inherit_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_inherit_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_inherit_timeline)>>(
          'spine_inherit_timeline_cast_to_timeline');
  late final _spine_inherit_timeline_cast_to_timeline =
      _spine_inherit_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_inherit_timeline)>();

  spine_bone_timeline spine_inherit_timeline_cast_to_bone_timeline(
    spine_inherit_timeline obj,
  ) {
    return _spine_inherit_timeline_cast_to_bone_timeline(
      obj,
    );
  }

  late final _spine_inherit_timeline_cast_to_bone_timelinePtr =
      _lookup<ffi.NativeFunction<spine_bone_timeline Function(spine_inherit_timeline)>>(
          'spine_inherit_timeline_cast_to_bone_timeline');
  late final _spine_inherit_timeline_cast_to_bone_timeline = _spine_inherit_timeline_cast_to_bone_timelinePtr
      .asFunction<spine_bone_timeline Function(spine_inherit_timeline)>();

  spine_vertex_attachment spine_mesh_attachment_cast_to_vertex_attachment(
    spine_mesh_attachment obj,
  ) {
    return _spine_mesh_attachment_cast_to_vertex_attachment(
      obj,
    );
  }

  late final _spine_mesh_attachment_cast_to_vertex_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_vertex_attachment Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_cast_to_vertex_attachment');
  late final _spine_mesh_attachment_cast_to_vertex_attachment = _spine_mesh_attachment_cast_to_vertex_attachmentPtr
      .asFunction<spine_vertex_attachment Function(spine_mesh_attachment)>();

  spine_attachment spine_mesh_attachment_cast_to_attachment(
    spine_mesh_attachment obj,
  ) {
    return _spine_mesh_attachment_cast_to_attachment(
      obj,
    );
  }

  late final _spine_mesh_attachment_cast_to_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_cast_to_attachment');
  late final _spine_mesh_attachment_cast_to_attachment =
      _spine_mesh_attachment_cast_to_attachmentPtr.asFunction<spine_attachment Function(spine_mesh_attachment)>();

  spine_vertex_attachment spine_path_attachment_cast_to_vertex_attachment(
    spine_path_attachment obj,
  ) {
    return _spine_path_attachment_cast_to_vertex_attachment(
      obj,
    );
  }

  late final _spine_path_attachment_cast_to_vertex_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_vertex_attachment Function(spine_path_attachment)>>(
          'spine_path_attachment_cast_to_vertex_attachment');
  late final _spine_path_attachment_cast_to_vertex_attachment = _spine_path_attachment_cast_to_vertex_attachmentPtr
      .asFunction<spine_vertex_attachment Function(spine_path_attachment)>();

  spine_attachment spine_path_attachment_cast_to_attachment(
    spine_path_attachment obj,
  ) {
    return _spine_path_attachment_cast_to_attachment(
      obj,
    );
  }

  late final _spine_path_attachment_cast_to_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_path_attachment)>>(
          'spine_path_attachment_cast_to_attachment');
  late final _spine_path_attachment_cast_to_attachment =
      _spine_path_attachment_cast_to_attachmentPtr.asFunction<spine_attachment Function(spine_path_attachment)>();

  spine_path_constraint_base spine_path_constraint_cast_to_path_constraint_base(
    spine_path_constraint obj,
  ) {
    return _spine_path_constraint_cast_to_path_constraint_base(
      obj,
    );
  }

  late final _spine_path_constraint_cast_to_path_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_base Function(spine_path_constraint)>>(
          'spine_path_constraint_cast_to_path_constraint_base');
  late final _spine_path_constraint_cast_to_path_constraint_base =
      _spine_path_constraint_cast_to_path_constraint_basePtr
          .asFunction<spine_path_constraint_base Function(spine_path_constraint)>();

  spine_posed spine_path_constraint_cast_to_posed(
    spine_path_constraint obj,
  ) {
    return _spine_path_constraint_cast_to_posed(
      obj,
    );
  }

  late final _spine_path_constraint_cast_to_posedPtr =
      _lookup<ffi.NativeFunction<spine_posed Function(spine_path_constraint)>>('spine_path_constraint_cast_to_posed');
  late final _spine_path_constraint_cast_to_posed =
      _spine_path_constraint_cast_to_posedPtr.asFunction<spine_posed Function(spine_path_constraint)>();

  spine_posed_active spine_path_constraint_cast_to_posed_active(
    spine_path_constraint obj,
  ) {
    return _spine_path_constraint_cast_to_posed_active(
      obj,
    );
  }

  late final _spine_path_constraint_cast_to_posed_activePtr =
      _lookup<ffi.NativeFunction<spine_posed_active Function(spine_path_constraint)>>(
          'spine_path_constraint_cast_to_posed_active');
  late final _spine_path_constraint_cast_to_posed_active =
      _spine_path_constraint_cast_to_posed_activePtr.asFunction<spine_posed_active Function(spine_path_constraint)>();

  spine_constraint spine_path_constraint_cast_to_constraint(
    spine_path_constraint obj,
  ) {
    return _spine_path_constraint_cast_to_constraint(
      obj,
    );
  }

  late final _spine_path_constraint_cast_to_constraintPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_path_constraint)>>(
          'spine_path_constraint_cast_to_constraint');
  late final _spine_path_constraint_cast_to_constraint =
      _spine_path_constraint_cast_to_constraintPtr.asFunction<spine_constraint Function(spine_path_constraint)>();

  spine_update spine_path_constraint_cast_to_update(
    spine_path_constraint obj,
  ) {
    return _spine_path_constraint_cast_to_update(
      obj,
    );
  }

  late final _spine_path_constraint_cast_to_updatePtr =
      _lookup<ffi.NativeFunction<spine_update Function(spine_path_constraint)>>('spine_path_constraint_cast_to_update');
  late final _spine_path_constraint_cast_to_update =
      _spine_path_constraint_cast_to_updatePtr.asFunction<spine_update Function(spine_path_constraint)>();

  spine_posed spine_path_constraint_base_cast_to_posed(
    spine_path_constraint_base obj,
  ) {
    return _spine_path_constraint_base_cast_to_posed(
      obj,
    );
  }

  late final _spine_path_constraint_base_cast_to_posedPtr =
      _lookup<ffi.NativeFunction<spine_posed Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_cast_to_posed');
  late final _spine_path_constraint_base_cast_to_posed =
      _spine_path_constraint_base_cast_to_posedPtr.asFunction<spine_posed Function(spine_path_constraint_base)>();

  spine_posed_active spine_path_constraint_base_cast_to_posed_active(
    spine_path_constraint_base obj,
  ) {
    return _spine_path_constraint_base_cast_to_posed_active(
      obj,
    );
  }

  late final _spine_path_constraint_base_cast_to_posed_activePtr =
      _lookup<ffi.NativeFunction<spine_posed_active Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_cast_to_posed_active');
  late final _spine_path_constraint_base_cast_to_posed_active = _spine_path_constraint_base_cast_to_posed_activePtr
      .asFunction<spine_posed_active Function(spine_path_constraint_base)>();

  spine_constraint spine_path_constraint_base_cast_to_constraint(
    spine_path_constraint_base obj,
  ) {
    return _spine_path_constraint_base_cast_to_constraint(
      obj,
    );
  }

  late final _spine_path_constraint_base_cast_to_constraintPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_cast_to_constraint');
  late final _spine_path_constraint_base_cast_to_constraint = _spine_path_constraint_base_cast_to_constraintPtr
      .asFunction<spine_constraint Function(spine_path_constraint_base)>();

  spine_update spine_path_constraint_base_cast_to_update(
    spine_path_constraint_base obj,
  ) {
    return _spine_path_constraint_base_cast_to_update(
      obj,
    );
  }

  late final _spine_path_constraint_base_cast_to_updatePtr =
      _lookup<ffi.NativeFunction<spine_update Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_cast_to_update');
  late final _spine_path_constraint_base_cast_to_update =
      _spine_path_constraint_base_cast_to_updatePtr.asFunction<spine_update Function(spine_path_constraint_base)>();

  spine_posed_data spine_path_constraint_data_cast_to_posed_data(
    spine_path_constraint_data obj,
  ) {
    return _spine_path_constraint_data_cast_to_posed_data(
      obj,
    );
  }

  late final _spine_path_constraint_data_cast_to_posed_dataPtr =
      _lookup<ffi.NativeFunction<spine_posed_data Function(spine_path_constraint_data)>>(
          'spine_path_constraint_data_cast_to_posed_data');
  late final _spine_path_constraint_data_cast_to_posed_data = _spine_path_constraint_data_cast_to_posed_dataPtr
      .asFunction<spine_posed_data Function(spine_path_constraint_data)>();

  spine_constraint_data spine_path_constraint_data_cast_to_constraint_data(
    spine_path_constraint_data obj,
  ) {
    return _spine_path_constraint_data_cast_to_constraint_data(
      obj,
    );
  }

  late final _spine_path_constraint_data_cast_to_constraint_dataPtr =
      _lookup<ffi.NativeFunction<spine_constraint_data Function(spine_path_constraint_data)>>(
          'spine_path_constraint_data_cast_to_constraint_data');
  late final _spine_path_constraint_data_cast_to_constraint_data =
      _spine_path_constraint_data_cast_to_constraint_dataPtr
          .asFunction<spine_constraint_data Function(spine_path_constraint_data)>();

  spine_curve_timeline spine_path_constraint_mix_timeline_cast_to_curve_timeline(
    spine_path_constraint_mix_timeline obj,
  ) {
    return _spine_path_constraint_mix_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_path_constraint_mix_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_path_constraint_mix_timeline)>>(
          'spine_path_constraint_mix_timeline_cast_to_curve_timeline');
  late final _spine_path_constraint_mix_timeline_cast_to_curve_timeline =
      _spine_path_constraint_mix_timeline_cast_to_curve_timelinePtr
          .asFunction<spine_curve_timeline Function(spine_path_constraint_mix_timeline)>();

  spine_timeline spine_path_constraint_mix_timeline_cast_to_timeline(
    spine_path_constraint_mix_timeline obj,
  ) {
    return _spine_path_constraint_mix_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_path_constraint_mix_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_path_constraint_mix_timeline)>>(
          'spine_path_constraint_mix_timeline_cast_to_timeline');
  late final _spine_path_constraint_mix_timeline_cast_to_timeline =
      _spine_path_constraint_mix_timeline_cast_to_timelinePtr
          .asFunction<spine_timeline Function(spine_path_constraint_mix_timeline)>();

  spine_constraint_timeline spine_path_constraint_mix_timeline_cast_to_constraint_timeline(
    spine_path_constraint_mix_timeline obj,
  ) {
    return _spine_path_constraint_mix_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_path_constraint_mix_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_path_constraint_mix_timeline)>>(
          'spine_path_constraint_mix_timeline_cast_to_constraint_timeline');
  late final _spine_path_constraint_mix_timeline_cast_to_constraint_timeline =
      _spine_path_constraint_mix_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_path_constraint_mix_timeline)>();

  spine_constraint_timeline1 spine_path_constraint_position_timeline_cast_to_constraint_timeline1(
    spine_path_constraint_position_timeline obj,
  ) {
    return _spine_path_constraint_position_timeline_cast_to_constraint_timeline1(
      obj,
    );
  }

  late final _spine_path_constraint_position_timeline_cast_to_constraint_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline1 Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_cast_to_constraint_timeline1');
  late final _spine_path_constraint_position_timeline_cast_to_constraint_timeline1 =
      _spine_path_constraint_position_timeline_cast_to_constraint_timeline1Ptr
          .asFunction<spine_constraint_timeline1 Function(spine_path_constraint_position_timeline)>();

  spine_curve_timeline1 spine_path_constraint_position_timeline_cast_to_curve_timeline1(
    spine_path_constraint_position_timeline obj,
  ) {
    return _spine_path_constraint_position_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_path_constraint_position_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_cast_to_curve_timeline1');
  late final _spine_path_constraint_position_timeline_cast_to_curve_timeline1 =
      _spine_path_constraint_position_timeline_cast_to_curve_timeline1Ptr
          .asFunction<spine_curve_timeline1 Function(spine_path_constraint_position_timeline)>();

  spine_curve_timeline spine_path_constraint_position_timeline_cast_to_curve_timeline(
    spine_path_constraint_position_timeline obj,
  ) {
    return _spine_path_constraint_position_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_path_constraint_position_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_cast_to_curve_timeline');
  late final _spine_path_constraint_position_timeline_cast_to_curve_timeline =
      _spine_path_constraint_position_timeline_cast_to_curve_timelinePtr
          .asFunction<spine_curve_timeline Function(spine_path_constraint_position_timeline)>();

  spine_timeline spine_path_constraint_position_timeline_cast_to_timeline(
    spine_path_constraint_position_timeline obj,
  ) {
    return _spine_path_constraint_position_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_path_constraint_position_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_cast_to_timeline');
  late final _spine_path_constraint_position_timeline_cast_to_timeline =
      _spine_path_constraint_position_timeline_cast_to_timelinePtr
          .asFunction<spine_timeline Function(spine_path_constraint_position_timeline)>();

  spine_constraint_timeline spine_path_constraint_position_timeline_cast_to_constraint_timeline(
    spine_path_constraint_position_timeline obj,
  ) {
    return _spine_path_constraint_position_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_path_constraint_position_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_cast_to_constraint_timeline');
  late final _spine_path_constraint_position_timeline_cast_to_constraint_timeline =
      _spine_path_constraint_position_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_path_constraint_position_timeline)>();

  spine_constraint_timeline1 spine_path_constraint_spacing_timeline_cast_to_constraint_timeline1(
    spine_path_constraint_spacing_timeline obj,
  ) {
    return _spine_path_constraint_spacing_timeline_cast_to_constraint_timeline1(
      obj,
    );
  }

  late final _spine_path_constraint_spacing_timeline_cast_to_constraint_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline1 Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_cast_to_constraint_timeline1');
  late final _spine_path_constraint_spacing_timeline_cast_to_constraint_timeline1 =
      _spine_path_constraint_spacing_timeline_cast_to_constraint_timeline1Ptr
          .asFunction<spine_constraint_timeline1 Function(spine_path_constraint_spacing_timeline)>();

  spine_curve_timeline1 spine_path_constraint_spacing_timeline_cast_to_curve_timeline1(
    spine_path_constraint_spacing_timeline obj,
  ) {
    return _spine_path_constraint_spacing_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_path_constraint_spacing_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_cast_to_curve_timeline1');
  late final _spine_path_constraint_spacing_timeline_cast_to_curve_timeline1 =
      _spine_path_constraint_spacing_timeline_cast_to_curve_timeline1Ptr
          .asFunction<spine_curve_timeline1 Function(spine_path_constraint_spacing_timeline)>();

  spine_curve_timeline spine_path_constraint_spacing_timeline_cast_to_curve_timeline(
    spine_path_constraint_spacing_timeline obj,
  ) {
    return _spine_path_constraint_spacing_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_path_constraint_spacing_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_cast_to_curve_timeline');
  late final _spine_path_constraint_spacing_timeline_cast_to_curve_timeline =
      _spine_path_constraint_spacing_timeline_cast_to_curve_timelinePtr
          .asFunction<spine_curve_timeline Function(spine_path_constraint_spacing_timeline)>();

  spine_timeline spine_path_constraint_spacing_timeline_cast_to_timeline(
    spine_path_constraint_spacing_timeline obj,
  ) {
    return _spine_path_constraint_spacing_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_path_constraint_spacing_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_cast_to_timeline');
  late final _spine_path_constraint_spacing_timeline_cast_to_timeline =
      _spine_path_constraint_spacing_timeline_cast_to_timelinePtr
          .asFunction<spine_timeline Function(spine_path_constraint_spacing_timeline)>();

  spine_constraint_timeline spine_path_constraint_spacing_timeline_cast_to_constraint_timeline(
    spine_path_constraint_spacing_timeline obj,
  ) {
    return _spine_path_constraint_spacing_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_path_constraint_spacing_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_cast_to_constraint_timeline');
  late final _spine_path_constraint_spacing_timeline_cast_to_constraint_timeline =
      _spine_path_constraint_spacing_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_path_constraint_spacing_timeline)>();

  spine_physics_constraint_base spine_physics_constraint_cast_to_physics_constraint_base(
    spine_physics_constraint obj,
  ) {
    return _spine_physics_constraint_cast_to_physics_constraint_base(
      obj,
    );
  }

  late final _spine_physics_constraint_cast_to_physics_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_base Function(spine_physics_constraint)>>(
          'spine_physics_constraint_cast_to_physics_constraint_base');
  late final _spine_physics_constraint_cast_to_physics_constraint_base =
      _spine_physics_constraint_cast_to_physics_constraint_basePtr
          .asFunction<spine_physics_constraint_base Function(spine_physics_constraint)>();

  spine_posed spine_physics_constraint_cast_to_posed(
    spine_physics_constraint obj,
  ) {
    return _spine_physics_constraint_cast_to_posed(
      obj,
    );
  }

  late final _spine_physics_constraint_cast_to_posedPtr =
      _lookup<ffi.NativeFunction<spine_posed Function(spine_physics_constraint)>>(
          'spine_physics_constraint_cast_to_posed');
  late final _spine_physics_constraint_cast_to_posed =
      _spine_physics_constraint_cast_to_posedPtr.asFunction<spine_posed Function(spine_physics_constraint)>();

  spine_posed_active spine_physics_constraint_cast_to_posed_active(
    spine_physics_constraint obj,
  ) {
    return _spine_physics_constraint_cast_to_posed_active(
      obj,
    );
  }

  late final _spine_physics_constraint_cast_to_posed_activePtr =
      _lookup<ffi.NativeFunction<spine_posed_active Function(spine_physics_constraint)>>(
          'spine_physics_constraint_cast_to_posed_active');
  late final _spine_physics_constraint_cast_to_posed_active = _spine_physics_constraint_cast_to_posed_activePtr
      .asFunction<spine_posed_active Function(spine_physics_constraint)>();

  spine_constraint spine_physics_constraint_cast_to_constraint(
    spine_physics_constraint obj,
  ) {
    return _spine_physics_constraint_cast_to_constraint(
      obj,
    );
  }

  late final _spine_physics_constraint_cast_to_constraintPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_physics_constraint)>>(
          'spine_physics_constraint_cast_to_constraint');
  late final _spine_physics_constraint_cast_to_constraint =
      _spine_physics_constraint_cast_to_constraintPtr.asFunction<spine_constraint Function(spine_physics_constraint)>();

  spine_update spine_physics_constraint_cast_to_update(
    spine_physics_constraint obj,
  ) {
    return _spine_physics_constraint_cast_to_update(
      obj,
    );
  }

  late final _spine_physics_constraint_cast_to_updatePtr =
      _lookup<ffi.NativeFunction<spine_update Function(spine_physics_constraint)>>(
          'spine_physics_constraint_cast_to_update');
  late final _spine_physics_constraint_cast_to_update =
      _spine_physics_constraint_cast_to_updatePtr.asFunction<spine_update Function(spine_physics_constraint)>();

  spine_posed spine_physics_constraint_base_cast_to_posed(
    spine_physics_constraint_base obj,
  ) {
    return _spine_physics_constraint_base_cast_to_posed(
      obj,
    );
  }

  late final _spine_physics_constraint_base_cast_to_posedPtr =
      _lookup<ffi.NativeFunction<spine_posed Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_cast_to_posed');
  late final _spine_physics_constraint_base_cast_to_posed =
      _spine_physics_constraint_base_cast_to_posedPtr.asFunction<spine_posed Function(spine_physics_constraint_base)>();

  spine_posed_active spine_physics_constraint_base_cast_to_posed_active(
    spine_physics_constraint_base obj,
  ) {
    return _spine_physics_constraint_base_cast_to_posed_active(
      obj,
    );
  }

  late final _spine_physics_constraint_base_cast_to_posed_activePtr =
      _lookup<ffi.NativeFunction<spine_posed_active Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_cast_to_posed_active');
  late final _spine_physics_constraint_base_cast_to_posed_active =
      _spine_physics_constraint_base_cast_to_posed_activePtr
          .asFunction<spine_posed_active Function(spine_physics_constraint_base)>();

  spine_constraint spine_physics_constraint_base_cast_to_constraint(
    spine_physics_constraint_base obj,
  ) {
    return _spine_physics_constraint_base_cast_to_constraint(
      obj,
    );
  }

  late final _spine_physics_constraint_base_cast_to_constraintPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_cast_to_constraint');
  late final _spine_physics_constraint_base_cast_to_constraint = _spine_physics_constraint_base_cast_to_constraintPtr
      .asFunction<spine_constraint Function(spine_physics_constraint_base)>();

  spine_update spine_physics_constraint_base_cast_to_update(
    spine_physics_constraint_base obj,
  ) {
    return _spine_physics_constraint_base_cast_to_update(
      obj,
    );
  }

  late final _spine_physics_constraint_base_cast_to_updatePtr =
      _lookup<ffi.NativeFunction<spine_update Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_cast_to_update');
  late final _spine_physics_constraint_base_cast_to_update = _spine_physics_constraint_base_cast_to_updatePtr
      .asFunction<spine_update Function(spine_physics_constraint_base)>();

  spine_physics_constraint_timeline spine_physics_constraint_damping_timeline_cast_to_physics_constraint_timeline(
    spine_physics_constraint_damping_timeline obj,
  ) {
    return _spine_physics_constraint_damping_timeline_cast_to_physics_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_damping_timeline_cast_to_physics_constraint_timelinePtr = _lookup<
          ffi.NativeFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_damping_timeline)>>(
      'spine_physics_constraint_damping_timeline_cast_to_physics_constraint_timeline');
  late final _spine_physics_constraint_damping_timeline_cast_to_physics_constraint_timeline =
      _spine_physics_constraint_damping_timeline_cast_to_physics_constraint_timelinePtr
          .asFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_damping_timeline)>();

  spine_curve_timeline1 spine_physics_constraint_damping_timeline_cast_to_curve_timeline1(
    spine_physics_constraint_damping_timeline obj,
  ) {
    return _spine_physics_constraint_damping_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_physics_constraint_damping_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_cast_to_curve_timeline1');
  late final _spine_physics_constraint_damping_timeline_cast_to_curve_timeline1 =
      _spine_physics_constraint_damping_timeline_cast_to_curve_timeline1Ptr
          .asFunction<spine_curve_timeline1 Function(spine_physics_constraint_damping_timeline)>();

  spine_curve_timeline spine_physics_constraint_damping_timeline_cast_to_curve_timeline(
    spine_physics_constraint_damping_timeline obj,
  ) {
    return _spine_physics_constraint_damping_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_damping_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_cast_to_curve_timeline');
  late final _spine_physics_constraint_damping_timeline_cast_to_curve_timeline =
      _spine_physics_constraint_damping_timeline_cast_to_curve_timelinePtr
          .asFunction<spine_curve_timeline Function(spine_physics_constraint_damping_timeline)>();

  spine_timeline spine_physics_constraint_damping_timeline_cast_to_timeline(
    spine_physics_constraint_damping_timeline obj,
  ) {
    return _spine_physics_constraint_damping_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_damping_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_cast_to_timeline');
  late final _spine_physics_constraint_damping_timeline_cast_to_timeline =
      _spine_physics_constraint_damping_timeline_cast_to_timelinePtr
          .asFunction<spine_timeline Function(spine_physics_constraint_damping_timeline)>();

  spine_constraint_timeline spine_physics_constraint_damping_timeline_cast_to_constraint_timeline(
    spine_physics_constraint_damping_timeline obj,
  ) {
    return _spine_physics_constraint_damping_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_damping_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_cast_to_constraint_timeline');
  late final _spine_physics_constraint_damping_timeline_cast_to_constraint_timeline =
      _spine_physics_constraint_damping_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_physics_constraint_damping_timeline)>();

  spine_posed_data spine_physics_constraint_data_cast_to_posed_data(
    spine_physics_constraint_data obj,
  ) {
    return _spine_physics_constraint_data_cast_to_posed_data(
      obj,
    );
  }

  late final _spine_physics_constraint_data_cast_to_posed_dataPtr =
      _lookup<ffi.NativeFunction<spine_posed_data Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_cast_to_posed_data');
  late final _spine_physics_constraint_data_cast_to_posed_data = _spine_physics_constraint_data_cast_to_posed_dataPtr
      .asFunction<spine_posed_data Function(spine_physics_constraint_data)>();

  spine_constraint_data spine_physics_constraint_data_cast_to_constraint_data(
    spine_physics_constraint_data obj,
  ) {
    return _spine_physics_constraint_data_cast_to_constraint_data(
      obj,
    );
  }

  late final _spine_physics_constraint_data_cast_to_constraint_dataPtr =
      _lookup<ffi.NativeFunction<spine_constraint_data Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_cast_to_constraint_data');
  late final _spine_physics_constraint_data_cast_to_constraint_data =
      _spine_physics_constraint_data_cast_to_constraint_dataPtr
          .asFunction<spine_constraint_data Function(spine_physics_constraint_data)>();

  spine_physics_constraint_timeline spine_physics_constraint_gravity_timeline_cast_to_physics_constraint_timeline(
    spine_physics_constraint_gravity_timeline obj,
  ) {
    return _spine_physics_constraint_gravity_timeline_cast_to_physics_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_cast_to_physics_constraint_timelinePtr = _lookup<
          ffi.NativeFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_gravity_timeline)>>(
      'spine_physics_constraint_gravity_timeline_cast_to_physics_constraint_timeline');
  late final _spine_physics_constraint_gravity_timeline_cast_to_physics_constraint_timeline =
      _spine_physics_constraint_gravity_timeline_cast_to_physics_constraint_timelinePtr
          .asFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_gravity_timeline)>();

  spine_curve_timeline1 spine_physics_constraint_gravity_timeline_cast_to_curve_timeline1(
    spine_physics_constraint_gravity_timeline obj,
  ) {
    return _spine_physics_constraint_gravity_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_cast_to_curve_timeline1');
  late final _spine_physics_constraint_gravity_timeline_cast_to_curve_timeline1 =
      _spine_physics_constraint_gravity_timeline_cast_to_curve_timeline1Ptr
          .asFunction<spine_curve_timeline1 Function(spine_physics_constraint_gravity_timeline)>();

  spine_curve_timeline spine_physics_constraint_gravity_timeline_cast_to_curve_timeline(
    spine_physics_constraint_gravity_timeline obj,
  ) {
    return _spine_physics_constraint_gravity_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_cast_to_curve_timeline');
  late final _spine_physics_constraint_gravity_timeline_cast_to_curve_timeline =
      _spine_physics_constraint_gravity_timeline_cast_to_curve_timelinePtr
          .asFunction<spine_curve_timeline Function(spine_physics_constraint_gravity_timeline)>();

  spine_timeline spine_physics_constraint_gravity_timeline_cast_to_timeline(
    spine_physics_constraint_gravity_timeline obj,
  ) {
    return _spine_physics_constraint_gravity_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_cast_to_timeline');
  late final _spine_physics_constraint_gravity_timeline_cast_to_timeline =
      _spine_physics_constraint_gravity_timeline_cast_to_timelinePtr
          .asFunction<spine_timeline Function(spine_physics_constraint_gravity_timeline)>();

  spine_constraint_timeline spine_physics_constraint_gravity_timeline_cast_to_constraint_timeline(
    spine_physics_constraint_gravity_timeline obj,
  ) {
    return _spine_physics_constraint_gravity_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_cast_to_constraint_timeline');
  late final _spine_physics_constraint_gravity_timeline_cast_to_constraint_timeline =
      _spine_physics_constraint_gravity_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_physics_constraint_gravity_timeline)>();

  spine_physics_constraint_timeline spine_physics_constraint_inertia_timeline_cast_to_physics_constraint_timeline(
    spine_physics_constraint_inertia_timeline obj,
  ) {
    return _spine_physics_constraint_inertia_timeline_cast_to_physics_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_cast_to_physics_constraint_timelinePtr = _lookup<
          ffi.NativeFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_inertia_timeline)>>(
      'spine_physics_constraint_inertia_timeline_cast_to_physics_constraint_timeline');
  late final _spine_physics_constraint_inertia_timeline_cast_to_physics_constraint_timeline =
      _spine_physics_constraint_inertia_timeline_cast_to_physics_constraint_timelinePtr
          .asFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_inertia_timeline)>();

  spine_curve_timeline1 spine_physics_constraint_inertia_timeline_cast_to_curve_timeline1(
    spine_physics_constraint_inertia_timeline obj,
  ) {
    return _spine_physics_constraint_inertia_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_cast_to_curve_timeline1');
  late final _spine_physics_constraint_inertia_timeline_cast_to_curve_timeline1 =
      _spine_physics_constraint_inertia_timeline_cast_to_curve_timeline1Ptr
          .asFunction<spine_curve_timeline1 Function(spine_physics_constraint_inertia_timeline)>();

  spine_curve_timeline spine_physics_constraint_inertia_timeline_cast_to_curve_timeline(
    spine_physics_constraint_inertia_timeline obj,
  ) {
    return _spine_physics_constraint_inertia_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_cast_to_curve_timeline');
  late final _spine_physics_constraint_inertia_timeline_cast_to_curve_timeline =
      _spine_physics_constraint_inertia_timeline_cast_to_curve_timelinePtr
          .asFunction<spine_curve_timeline Function(spine_physics_constraint_inertia_timeline)>();

  spine_timeline spine_physics_constraint_inertia_timeline_cast_to_timeline(
    spine_physics_constraint_inertia_timeline obj,
  ) {
    return _spine_physics_constraint_inertia_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_cast_to_timeline');
  late final _spine_physics_constraint_inertia_timeline_cast_to_timeline =
      _spine_physics_constraint_inertia_timeline_cast_to_timelinePtr
          .asFunction<spine_timeline Function(spine_physics_constraint_inertia_timeline)>();

  spine_constraint_timeline spine_physics_constraint_inertia_timeline_cast_to_constraint_timeline(
    spine_physics_constraint_inertia_timeline obj,
  ) {
    return _spine_physics_constraint_inertia_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_cast_to_constraint_timeline');
  late final _spine_physics_constraint_inertia_timeline_cast_to_constraint_timeline =
      _spine_physics_constraint_inertia_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_physics_constraint_inertia_timeline)>();

  spine_physics_constraint_timeline spine_physics_constraint_mass_timeline_cast_to_physics_constraint_timeline(
    spine_physics_constraint_mass_timeline obj,
  ) {
    return _spine_physics_constraint_mass_timeline_cast_to_physics_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_mass_timeline_cast_to_physics_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_cast_to_physics_constraint_timeline');
  late final _spine_physics_constraint_mass_timeline_cast_to_physics_constraint_timeline =
      _spine_physics_constraint_mass_timeline_cast_to_physics_constraint_timelinePtr
          .asFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_mass_timeline)>();

  spine_curve_timeline1 spine_physics_constraint_mass_timeline_cast_to_curve_timeline1(
    spine_physics_constraint_mass_timeline obj,
  ) {
    return _spine_physics_constraint_mass_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_physics_constraint_mass_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_cast_to_curve_timeline1');
  late final _spine_physics_constraint_mass_timeline_cast_to_curve_timeline1 =
      _spine_physics_constraint_mass_timeline_cast_to_curve_timeline1Ptr
          .asFunction<spine_curve_timeline1 Function(spine_physics_constraint_mass_timeline)>();

  spine_curve_timeline spine_physics_constraint_mass_timeline_cast_to_curve_timeline(
    spine_physics_constraint_mass_timeline obj,
  ) {
    return _spine_physics_constraint_mass_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_mass_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_cast_to_curve_timeline');
  late final _spine_physics_constraint_mass_timeline_cast_to_curve_timeline =
      _spine_physics_constraint_mass_timeline_cast_to_curve_timelinePtr
          .asFunction<spine_curve_timeline Function(spine_physics_constraint_mass_timeline)>();

  spine_timeline spine_physics_constraint_mass_timeline_cast_to_timeline(
    spine_physics_constraint_mass_timeline obj,
  ) {
    return _spine_physics_constraint_mass_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_mass_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_cast_to_timeline');
  late final _spine_physics_constraint_mass_timeline_cast_to_timeline =
      _spine_physics_constraint_mass_timeline_cast_to_timelinePtr
          .asFunction<spine_timeline Function(spine_physics_constraint_mass_timeline)>();

  spine_constraint_timeline spine_physics_constraint_mass_timeline_cast_to_constraint_timeline(
    spine_physics_constraint_mass_timeline obj,
  ) {
    return _spine_physics_constraint_mass_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_mass_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_cast_to_constraint_timeline');
  late final _spine_physics_constraint_mass_timeline_cast_to_constraint_timeline =
      _spine_physics_constraint_mass_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_physics_constraint_mass_timeline)>();

  spine_physics_constraint_timeline spine_physics_constraint_mix_timeline_cast_to_physics_constraint_timeline(
    spine_physics_constraint_mix_timeline obj,
  ) {
    return _spine_physics_constraint_mix_timeline_cast_to_physics_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_mix_timeline_cast_to_physics_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_cast_to_physics_constraint_timeline');
  late final _spine_physics_constraint_mix_timeline_cast_to_physics_constraint_timeline =
      _spine_physics_constraint_mix_timeline_cast_to_physics_constraint_timelinePtr
          .asFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_mix_timeline)>();

  spine_curve_timeline1 spine_physics_constraint_mix_timeline_cast_to_curve_timeline1(
    spine_physics_constraint_mix_timeline obj,
  ) {
    return _spine_physics_constraint_mix_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_physics_constraint_mix_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_cast_to_curve_timeline1');
  late final _spine_physics_constraint_mix_timeline_cast_to_curve_timeline1 =
      _spine_physics_constraint_mix_timeline_cast_to_curve_timeline1Ptr
          .asFunction<spine_curve_timeline1 Function(spine_physics_constraint_mix_timeline)>();

  spine_curve_timeline spine_physics_constraint_mix_timeline_cast_to_curve_timeline(
    spine_physics_constraint_mix_timeline obj,
  ) {
    return _spine_physics_constraint_mix_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_mix_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_cast_to_curve_timeline');
  late final _spine_physics_constraint_mix_timeline_cast_to_curve_timeline =
      _spine_physics_constraint_mix_timeline_cast_to_curve_timelinePtr
          .asFunction<spine_curve_timeline Function(spine_physics_constraint_mix_timeline)>();

  spine_timeline spine_physics_constraint_mix_timeline_cast_to_timeline(
    spine_physics_constraint_mix_timeline obj,
  ) {
    return _spine_physics_constraint_mix_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_mix_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_cast_to_timeline');
  late final _spine_physics_constraint_mix_timeline_cast_to_timeline =
      _spine_physics_constraint_mix_timeline_cast_to_timelinePtr
          .asFunction<spine_timeline Function(spine_physics_constraint_mix_timeline)>();

  spine_constraint_timeline spine_physics_constraint_mix_timeline_cast_to_constraint_timeline(
    spine_physics_constraint_mix_timeline obj,
  ) {
    return _spine_physics_constraint_mix_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_mix_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_cast_to_constraint_timeline');
  late final _spine_physics_constraint_mix_timeline_cast_to_constraint_timeline =
      _spine_physics_constraint_mix_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_physics_constraint_mix_timeline)>();

  spine_timeline spine_physics_constraint_reset_timeline_cast_to_timeline(
    spine_physics_constraint_reset_timeline obj,
  ) {
    return _spine_physics_constraint_reset_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_reset_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_cast_to_timeline');
  late final _spine_physics_constraint_reset_timeline_cast_to_timeline =
      _spine_physics_constraint_reset_timeline_cast_to_timelinePtr
          .asFunction<spine_timeline Function(spine_physics_constraint_reset_timeline)>();

  spine_constraint_timeline spine_physics_constraint_reset_timeline_cast_to_constraint_timeline(
    spine_physics_constraint_reset_timeline obj,
  ) {
    return _spine_physics_constraint_reset_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_reset_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_cast_to_constraint_timeline');
  late final _spine_physics_constraint_reset_timeline_cast_to_constraint_timeline =
      _spine_physics_constraint_reset_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_physics_constraint_reset_timeline)>();

  spine_physics_constraint_timeline spine_physics_constraint_strength_timeline_cast_to_physics_constraint_timeline(
    spine_physics_constraint_strength_timeline obj,
  ) {
    return _spine_physics_constraint_strength_timeline_cast_to_physics_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_strength_timeline_cast_to_physics_constraint_timelinePtr = _lookup<
          ffi.NativeFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_strength_timeline)>>(
      'spine_physics_constraint_strength_timeline_cast_to_physics_constraint_timeline');
  late final _spine_physics_constraint_strength_timeline_cast_to_physics_constraint_timeline =
      _spine_physics_constraint_strength_timeline_cast_to_physics_constraint_timelinePtr
          .asFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_strength_timeline)>();

  spine_curve_timeline1 spine_physics_constraint_strength_timeline_cast_to_curve_timeline1(
    spine_physics_constraint_strength_timeline obj,
  ) {
    return _spine_physics_constraint_strength_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_physics_constraint_strength_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_cast_to_curve_timeline1');
  late final _spine_physics_constraint_strength_timeline_cast_to_curve_timeline1 =
      _spine_physics_constraint_strength_timeline_cast_to_curve_timeline1Ptr
          .asFunction<spine_curve_timeline1 Function(spine_physics_constraint_strength_timeline)>();

  spine_curve_timeline spine_physics_constraint_strength_timeline_cast_to_curve_timeline(
    spine_physics_constraint_strength_timeline obj,
  ) {
    return _spine_physics_constraint_strength_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_strength_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_cast_to_curve_timeline');
  late final _spine_physics_constraint_strength_timeline_cast_to_curve_timeline =
      _spine_physics_constraint_strength_timeline_cast_to_curve_timelinePtr
          .asFunction<spine_curve_timeline Function(spine_physics_constraint_strength_timeline)>();

  spine_timeline spine_physics_constraint_strength_timeline_cast_to_timeline(
    spine_physics_constraint_strength_timeline obj,
  ) {
    return _spine_physics_constraint_strength_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_strength_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_cast_to_timeline');
  late final _spine_physics_constraint_strength_timeline_cast_to_timeline =
      _spine_physics_constraint_strength_timeline_cast_to_timelinePtr
          .asFunction<spine_timeline Function(spine_physics_constraint_strength_timeline)>();

  spine_constraint_timeline spine_physics_constraint_strength_timeline_cast_to_constraint_timeline(
    spine_physics_constraint_strength_timeline obj,
  ) {
    return _spine_physics_constraint_strength_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_strength_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_cast_to_constraint_timeline');
  late final _spine_physics_constraint_strength_timeline_cast_to_constraint_timeline =
      _spine_physics_constraint_strength_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_physics_constraint_strength_timeline)>();

  spine_curve_timeline1 spine_physics_constraint_timeline_cast_to_curve_timeline1(
    spine_physics_constraint_timeline obj,
  ) {
    return _spine_physics_constraint_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_physics_constraint_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_cast_to_curve_timeline1');
  late final _spine_physics_constraint_timeline_cast_to_curve_timeline1 =
      _spine_physics_constraint_timeline_cast_to_curve_timeline1Ptr
          .asFunction<spine_curve_timeline1 Function(spine_physics_constraint_timeline)>();

  spine_curve_timeline spine_physics_constraint_timeline_cast_to_curve_timeline(
    spine_physics_constraint_timeline obj,
  ) {
    return _spine_physics_constraint_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_cast_to_curve_timeline');
  late final _spine_physics_constraint_timeline_cast_to_curve_timeline =
      _spine_physics_constraint_timeline_cast_to_curve_timelinePtr
          .asFunction<spine_curve_timeline Function(spine_physics_constraint_timeline)>();

  spine_timeline spine_physics_constraint_timeline_cast_to_timeline(
    spine_physics_constraint_timeline obj,
  ) {
    return _spine_physics_constraint_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_cast_to_timeline');
  late final _spine_physics_constraint_timeline_cast_to_timeline =
      _spine_physics_constraint_timeline_cast_to_timelinePtr
          .asFunction<spine_timeline Function(spine_physics_constraint_timeline)>();

  spine_constraint_timeline spine_physics_constraint_timeline_cast_to_constraint_timeline(
    spine_physics_constraint_timeline obj,
  ) {
    return _spine_physics_constraint_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_cast_to_constraint_timeline');
  late final _spine_physics_constraint_timeline_cast_to_constraint_timeline =
      _spine_physics_constraint_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_physics_constraint_timeline)>();

  spine_physics_constraint_timeline spine_physics_constraint_wind_timeline_cast_to_physics_constraint_timeline(
    spine_physics_constraint_wind_timeline obj,
  ) {
    return _spine_physics_constraint_wind_timeline_cast_to_physics_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_wind_timeline_cast_to_physics_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_cast_to_physics_constraint_timeline');
  late final _spine_physics_constraint_wind_timeline_cast_to_physics_constraint_timeline =
      _spine_physics_constraint_wind_timeline_cast_to_physics_constraint_timelinePtr
          .asFunction<spine_physics_constraint_timeline Function(spine_physics_constraint_wind_timeline)>();

  spine_curve_timeline1 spine_physics_constraint_wind_timeline_cast_to_curve_timeline1(
    spine_physics_constraint_wind_timeline obj,
  ) {
    return _spine_physics_constraint_wind_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_physics_constraint_wind_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_cast_to_curve_timeline1');
  late final _spine_physics_constraint_wind_timeline_cast_to_curve_timeline1 =
      _spine_physics_constraint_wind_timeline_cast_to_curve_timeline1Ptr
          .asFunction<spine_curve_timeline1 Function(spine_physics_constraint_wind_timeline)>();

  spine_curve_timeline spine_physics_constraint_wind_timeline_cast_to_curve_timeline(
    spine_physics_constraint_wind_timeline obj,
  ) {
    return _spine_physics_constraint_wind_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_wind_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_cast_to_curve_timeline');
  late final _spine_physics_constraint_wind_timeline_cast_to_curve_timeline =
      _spine_physics_constraint_wind_timeline_cast_to_curve_timelinePtr
          .asFunction<spine_curve_timeline Function(spine_physics_constraint_wind_timeline)>();

  spine_timeline spine_physics_constraint_wind_timeline_cast_to_timeline(
    spine_physics_constraint_wind_timeline obj,
  ) {
    return _spine_physics_constraint_wind_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_wind_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_cast_to_timeline');
  late final _spine_physics_constraint_wind_timeline_cast_to_timeline =
      _spine_physics_constraint_wind_timeline_cast_to_timelinePtr
          .asFunction<spine_timeline Function(spine_physics_constraint_wind_timeline)>();

  spine_constraint_timeline spine_physics_constraint_wind_timeline_cast_to_constraint_timeline(
    spine_physics_constraint_wind_timeline obj,
  ) {
    return _spine_physics_constraint_wind_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_wind_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_cast_to_constraint_timeline');
  late final _spine_physics_constraint_wind_timeline_cast_to_constraint_timeline =
      _spine_physics_constraint_wind_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_physics_constraint_wind_timeline)>();

  spine_attachment spine_point_attachment_cast_to_attachment(
    spine_point_attachment obj,
  ) {
    return _spine_point_attachment_cast_to_attachment(
      obj,
    );
  }

  late final _spine_point_attachment_cast_to_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_point_attachment)>>(
          'spine_point_attachment_cast_to_attachment');
  late final _spine_point_attachment_cast_to_attachment =
      _spine_point_attachment_cast_to_attachmentPtr.asFunction<spine_attachment Function(spine_point_attachment)>();

  spine_attachment spine_region_attachment_cast_to_attachment(
    spine_region_attachment obj,
  ) {
    return _spine_region_attachment_cast_to_attachment(
      obj,
    );
  }

  late final _spine_region_attachment_cast_to_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_region_attachment)>>(
          'spine_region_attachment_cast_to_attachment');
  late final _spine_region_attachment_cast_to_attachment =
      _spine_region_attachment_cast_to_attachmentPtr.asFunction<spine_attachment Function(spine_region_attachment)>();

  spine_slot_curve_timeline spine_rgb2_timeline_cast_to_slot_curve_timeline(
    spine_rgb2_timeline obj,
  ) {
    return _spine_rgb2_timeline_cast_to_slot_curve_timeline(
      obj,
    );
  }

  late final _spine_rgb2_timeline_cast_to_slot_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_curve_timeline Function(spine_rgb2_timeline)>>(
          'spine_rgb2_timeline_cast_to_slot_curve_timeline');
  late final _spine_rgb2_timeline_cast_to_slot_curve_timeline = _spine_rgb2_timeline_cast_to_slot_curve_timelinePtr
      .asFunction<spine_slot_curve_timeline Function(spine_rgb2_timeline)>();

  spine_curve_timeline spine_rgb2_timeline_cast_to_curve_timeline(
    spine_rgb2_timeline obj,
  ) {
    return _spine_rgb2_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_rgb2_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_rgb2_timeline)>>(
          'spine_rgb2_timeline_cast_to_curve_timeline');
  late final _spine_rgb2_timeline_cast_to_curve_timeline =
      _spine_rgb2_timeline_cast_to_curve_timelinePtr.asFunction<spine_curve_timeline Function(spine_rgb2_timeline)>();

  spine_timeline spine_rgb2_timeline_cast_to_timeline(
    spine_rgb2_timeline obj,
  ) {
    return _spine_rgb2_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_rgb2_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_rgb2_timeline)>>('spine_rgb2_timeline_cast_to_timeline');
  late final _spine_rgb2_timeline_cast_to_timeline =
      _spine_rgb2_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_rgb2_timeline)>();

  spine_slot_timeline spine_rgb2_timeline_cast_to_slot_timeline(
    spine_rgb2_timeline obj,
  ) {
    return _spine_rgb2_timeline_cast_to_slot_timeline(
      obj,
    );
  }

  late final _spine_rgb2_timeline_cast_to_slot_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_timeline Function(spine_rgb2_timeline)>>(
          'spine_rgb2_timeline_cast_to_slot_timeline');
  late final _spine_rgb2_timeline_cast_to_slot_timeline =
      _spine_rgb2_timeline_cast_to_slot_timelinePtr.asFunction<spine_slot_timeline Function(spine_rgb2_timeline)>();

  spine_slot_curve_timeline spine_rgba2_timeline_cast_to_slot_curve_timeline(
    spine_rgba2_timeline obj,
  ) {
    return _spine_rgba2_timeline_cast_to_slot_curve_timeline(
      obj,
    );
  }

  late final _spine_rgba2_timeline_cast_to_slot_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_curve_timeline Function(spine_rgba2_timeline)>>(
          'spine_rgba2_timeline_cast_to_slot_curve_timeline');
  late final _spine_rgba2_timeline_cast_to_slot_curve_timeline = _spine_rgba2_timeline_cast_to_slot_curve_timelinePtr
      .asFunction<spine_slot_curve_timeline Function(spine_rgba2_timeline)>();

  spine_curve_timeline spine_rgba2_timeline_cast_to_curve_timeline(
    spine_rgba2_timeline obj,
  ) {
    return _spine_rgba2_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_rgba2_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_rgba2_timeline)>>(
          'spine_rgba2_timeline_cast_to_curve_timeline');
  late final _spine_rgba2_timeline_cast_to_curve_timeline =
      _spine_rgba2_timeline_cast_to_curve_timelinePtr.asFunction<spine_curve_timeline Function(spine_rgba2_timeline)>();

  spine_timeline spine_rgba2_timeline_cast_to_timeline(
    spine_rgba2_timeline obj,
  ) {
    return _spine_rgba2_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_rgba2_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_rgba2_timeline)>>(
          'spine_rgba2_timeline_cast_to_timeline');
  late final _spine_rgba2_timeline_cast_to_timeline =
      _spine_rgba2_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_rgba2_timeline)>();

  spine_slot_timeline spine_rgba2_timeline_cast_to_slot_timeline(
    spine_rgba2_timeline obj,
  ) {
    return _spine_rgba2_timeline_cast_to_slot_timeline(
      obj,
    );
  }

  late final _spine_rgba2_timeline_cast_to_slot_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_timeline Function(spine_rgba2_timeline)>>(
          'spine_rgba2_timeline_cast_to_slot_timeline');
  late final _spine_rgba2_timeline_cast_to_slot_timeline =
      _spine_rgba2_timeline_cast_to_slot_timelinePtr.asFunction<spine_slot_timeline Function(spine_rgba2_timeline)>();

  spine_slot_curve_timeline spine_rgba_timeline_cast_to_slot_curve_timeline(
    spine_rgba_timeline obj,
  ) {
    return _spine_rgba_timeline_cast_to_slot_curve_timeline(
      obj,
    );
  }

  late final _spine_rgba_timeline_cast_to_slot_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_curve_timeline Function(spine_rgba_timeline)>>(
          'spine_rgba_timeline_cast_to_slot_curve_timeline');
  late final _spine_rgba_timeline_cast_to_slot_curve_timeline = _spine_rgba_timeline_cast_to_slot_curve_timelinePtr
      .asFunction<spine_slot_curve_timeline Function(spine_rgba_timeline)>();

  spine_curve_timeline spine_rgba_timeline_cast_to_curve_timeline(
    spine_rgba_timeline obj,
  ) {
    return _spine_rgba_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_rgba_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_rgba_timeline)>>(
          'spine_rgba_timeline_cast_to_curve_timeline');
  late final _spine_rgba_timeline_cast_to_curve_timeline =
      _spine_rgba_timeline_cast_to_curve_timelinePtr.asFunction<spine_curve_timeline Function(spine_rgba_timeline)>();

  spine_timeline spine_rgba_timeline_cast_to_timeline(
    spine_rgba_timeline obj,
  ) {
    return _spine_rgba_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_rgba_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_rgba_timeline)>>('spine_rgba_timeline_cast_to_timeline');
  late final _spine_rgba_timeline_cast_to_timeline =
      _spine_rgba_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_rgba_timeline)>();

  spine_slot_timeline spine_rgba_timeline_cast_to_slot_timeline(
    spine_rgba_timeline obj,
  ) {
    return _spine_rgba_timeline_cast_to_slot_timeline(
      obj,
    );
  }

  late final _spine_rgba_timeline_cast_to_slot_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_timeline Function(spine_rgba_timeline)>>(
          'spine_rgba_timeline_cast_to_slot_timeline');
  late final _spine_rgba_timeline_cast_to_slot_timeline =
      _spine_rgba_timeline_cast_to_slot_timelinePtr.asFunction<spine_slot_timeline Function(spine_rgba_timeline)>();

  spine_slot_curve_timeline spine_rgb_timeline_cast_to_slot_curve_timeline(
    spine_rgb_timeline obj,
  ) {
    return _spine_rgb_timeline_cast_to_slot_curve_timeline(
      obj,
    );
  }

  late final _spine_rgb_timeline_cast_to_slot_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_curve_timeline Function(spine_rgb_timeline)>>(
          'spine_rgb_timeline_cast_to_slot_curve_timeline');
  late final _spine_rgb_timeline_cast_to_slot_curve_timeline = _spine_rgb_timeline_cast_to_slot_curve_timelinePtr
      .asFunction<spine_slot_curve_timeline Function(spine_rgb_timeline)>();

  spine_curve_timeline spine_rgb_timeline_cast_to_curve_timeline(
    spine_rgb_timeline obj,
  ) {
    return _spine_rgb_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_rgb_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_rgb_timeline)>>(
          'spine_rgb_timeline_cast_to_curve_timeline');
  late final _spine_rgb_timeline_cast_to_curve_timeline =
      _spine_rgb_timeline_cast_to_curve_timelinePtr.asFunction<spine_curve_timeline Function(spine_rgb_timeline)>();

  spine_timeline spine_rgb_timeline_cast_to_timeline(
    spine_rgb_timeline obj,
  ) {
    return _spine_rgb_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_rgb_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_rgb_timeline)>>('spine_rgb_timeline_cast_to_timeline');
  late final _spine_rgb_timeline_cast_to_timeline =
      _spine_rgb_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_rgb_timeline)>();

  spine_slot_timeline spine_rgb_timeline_cast_to_slot_timeline(
    spine_rgb_timeline obj,
  ) {
    return _spine_rgb_timeline_cast_to_slot_timeline(
      obj,
    );
  }

  late final _spine_rgb_timeline_cast_to_slot_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_timeline Function(spine_rgb_timeline)>>(
          'spine_rgb_timeline_cast_to_slot_timeline');
  late final _spine_rgb_timeline_cast_to_slot_timeline =
      _spine_rgb_timeline_cast_to_slot_timelinePtr.asFunction<spine_slot_timeline Function(spine_rgb_timeline)>();

  spine_bone_timeline1 spine_rotate_timeline_cast_to_bone_timeline1(
    spine_rotate_timeline obj,
  ) {
    return _spine_rotate_timeline_cast_to_bone_timeline1(
      obj,
    );
  }

  late final _spine_rotate_timeline_cast_to_bone_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline1 Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_cast_to_bone_timeline1');
  late final _spine_rotate_timeline_cast_to_bone_timeline1 = _spine_rotate_timeline_cast_to_bone_timeline1Ptr
      .asFunction<spine_bone_timeline1 Function(spine_rotate_timeline)>();

  spine_curve_timeline1 spine_rotate_timeline_cast_to_curve_timeline1(
    spine_rotate_timeline obj,
  ) {
    return _spine_rotate_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_rotate_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_cast_to_curve_timeline1');
  late final _spine_rotate_timeline_cast_to_curve_timeline1 = _spine_rotate_timeline_cast_to_curve_timeline1Ptr
      .asFunction<spine_curve_timeline1 Function(spine_rotate_timeline)>();

  spine_curve_timeline spine_rotate_timeline_cast_to_curve_timeline(
    spine_rotate_timeline obj,
  ) {
    return _spine_rotate_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_rotate_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_cast_to_curve_timeline');
  late final _spine_rotate_timeline_cast_to_curve_timeline = _spine_rotate_timeline_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_rotate_timeline)>();

  spine_timeline spine_rotate_timeline_cast_to_timeline(
    spine_rotate_timeline obj,
  ) {
    return _spine_rotate_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_rotate_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_cast_to_timeline');
  late final _spine_rotate_timeline_cast_to_timeline =
      _spine_rotate_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_rotate_timeline)>();

  spine_bone_timeline spine_rotate_timeline_cast_to_bone_timeline(
    spine_rotate_timeline obj,
  ) {
    return _spine_rotate_timeline_cast_to_bone_timeline(
      obj,
    );
  }

  late final _spine_rotate_timeline_cast_to_bone_timelinePtr =
      _lookup<ffi.NativeFunction<spine_bone_timeline Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_cast_to_bone_timeline');
  late final _spine_rotate_timeline_cast_to_bone_timeline =
      _spine_rotate_timeline_cast_to_bone_timelinePtr.asFunction<spine_bone_timeline Function(spine_rotate_timeline)>();

  spine_bone_timeline2 spine_scale_timeline_cast_to_bone_timeline2(
    spine_scale_timeline obj,
  ) {
    return _spine_scale_timeline_cast_to_bone_timeline2(
      obj,
    );
  }

  late final _spine_scale_timeline_cast_to_bone_timeline2Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline2 Function(spine_scale_timeline)>>(
          'spine_scale_timeline_cast_to_bone_timeline2');
  late final _spine_scale_timeline_cast_to_bone_timeline2 =
      _spine_scale_timeline_cast_to_bone_timeline2Ptr.asFunction<spine_bone_timeline2 Function(spine_scale_timeline)>();

  spine_curve_timeline spine_scale_timeline_cast_to_curve_timeline(
    spine_scale_timeline obj,
  ) {
    return _spine_scale_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_scale_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_scale_timeline)>>(
          'spine_scale_timeline_cast_to_curve_timeline');
  late final _spine_scale_timeline_cast_to_curve_timeline =
      _spine_scale_timeline_cast_to_curve_timelinePtr.asFunction<spine_curve_timeline Function(spine_scale_timeline)>();

  spine_timeline spine_scale_timeline_cast_to_timeline(
    spine_scale_timeline obj,
  ) {
    return _spine_scale_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_scale_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_scale_timeline)>>(
          'spine_scale_timeline_cast_to_timeline');
  late final _spine_scale_timeline_cast_to_timeline =
      _spine_scale_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_scale_timeline)>();

  spine_bone_timeline spine_scale_timeline_cast_to_bone_timeline(
    spine_scale_timeline obj,
  ) {
    return _spine_scale_timeline_cast_to_bone_timeline(
      obj,
    );
  }

  late final _spine_scale_timeline_cast_to_bone_timelinePtr =
      _lookup<ffi.NativeFunction<spine_bone_timeline Function(spine_scale_timeline)>>(
          'spine_scale_timeline_cast_to_bone_timeline');
  late final _spine_scale_timeline_cast_to_bone_timeline =
      _spine_scale_timeline_cast_to_bone_timelinePtr.asFunction<spine_bone_timeline Function(spine_scale_timeline)>();

  spine_bone_timeline1 spine_scale_x_timeline_cast_to_bone_timeline1(
    spine_scale_x_timeline obj,
  ) {
    return _spine_scale_x_timeline_cast_to_bone_timeline1(
      obj,
    );
  }

  late final _spine_scale_x_timeline_cast_to_bone_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline1 Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_cast_to_bone_timeline1');
  late final _spine_scale_x_timeline_cast_to_bone_timeline1 = _spine_scale_x_timeline_cast_to_bone_timeline1Ptr
      .asFunction<spine_bone_timeline1 Function(spine_scale_x_timeline)>();

  spine_curve_timeline1 spine_scale_x_timeline_cast_to_curve_timeline1(
    spine_scale_x_timeline obj,
  ) {
    return _spine_scale_x_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_scale_x_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_cast_to_curve_timeline1');
  late final _spine_scale_x_timeline_cast_to_curve_timeline1 = _spine_scale_x_timeline_cast_to_curve_timeline1Ptr
      .asFunction<spine_curve_timeline1 Function(spine_scale_x_timeline)>();

  spine_curve_timeline spine_scale_x_timeline_cast_to_curve_timeline(
    spine_scale_x_timeline obj,
  ) {
    return _spine_scale_x_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_scale_x_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_cast_to_curve_timeline');
  late final _spine_scale_x_timeline_cast_to_curve_timeline = _spine_scale_x_timeline_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_scale_x_timeline)>();

  spine_timeline spine_scale_x_timeline_cast_to_timeline(
    spine_scale_x_timeline obj,
  ) {
    return _spine_scale_x_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_scale_x_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_cast_to_timeline');
  late final _spine_scale_x_timeline_cast_to_timeline =
      _spine_scale_x_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_scale_x_timeline)>();

  spine_bone_timeline spine_scale_x_timeline_cast_to_bone_timeline(
    spine_scale_x_timeline obj,
  ) {
    return _spine_scale_x_timeline_cast_to_bone_timeline(
      obj,
    );
  }

  late final _spine_scale_x_timeline_cast_to_bone_timelinePtr =
      _lookup<ffi.NativeFunction<spine_bone_timeline Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_cast_to_bone_timeline');
  late final _spine_scale_x_timeline_cast_to_bone_timeline = _spine_scale_x_timeline_cast_to_bone_timelinePtr
      .asFunction<spine_bone_timeline Function(spine_scale_x_timeline)>();

  spine_bone_timeline1 spine_scale_y_timeline_cast_to_bone_timeline1(
    spine_scale_y_timeline obj,
  ) {
    return _spine_scale_y_timeline_cast_to_bone_timeline1(
      obj,
    );
  }

  late final _spine_scale_y_timeline_cast_to_bone_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline1 Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_cast_to_bone_timeline1');
  late final _spine_scale_y_timeline_cast_to_bone_timeline1 = _spine_scale_y_timeline_cast_to_bone_timeline1Ptr
      .asFunction<spine_bone_timeline1 Function(spine_scale_y_timeline)>();

  spine_curve_timeline1 spine_scale_y_timeline_cast_to_curve_timeline1(
    spine_scale_y_timeline obj,
  ) {
    return _spine_scale_y_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_scale_y_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_cast_to_curve_timeline1');
  late final _spine_scale_y_timeline_cast_to_curve_timeline1 = _spine_scale_y_timeline_cast_to_curve_timeline1Ptr
      .asFunction<spine_curve_timeline1 Function(spine_scale_y_timeline)>();

  spine_curve_timeline spine_scale_y_timeline_cast_to_curve_timeline(
    spine_scale_y_timeline obj,
  ) {
    return _spine_scale_y_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_scale_y_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_cast_to_curve_timeline');
  late final _spine_scale_y_timeline_cast_to_curve_timeline = _spine_scale_y_timeline_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_scale_y_timeline)>();

  spine_timeline spine_scale_y_timeline_cast_to_timeline(
    spine_scale_y_timeline obj,
  ) {
    return _spine_scale_y_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_scale_y_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_cast_to_timeline');
  late final _spine_scale_y_timeline_cast_to_timeline =
      _spine_scale_y_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_scale_y_timeline)>();

  spine_bone_timeline spine_scale_y_timeline_cast_to_bone_timeline(
    spine_scale_y_timeline obj,
  ) {
    return _spine_scale_y_timeline_cast_to_bone_timeline(
      obj,
    );
  }

  late final _spine_scale_y_timeline_cast_to_bone_timelinePtr =
      _lookup<ffi.NativeFunction<spine_bone_timeline Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_cast_to_bone_timeline');
  late final _spine_scale_y_timeline_cast_to_bone_timeline = _spine_scale_y_timeline_cast_to_bone_timelinePtr
      .asFunction<spine_bone_timeline Function(spine_scale_y_timeline)>();

  spine_timeline spine_sequence_timeline_cast_to_timeline(
    spine_sequence_timeline obj,
  ) {
    return _spine_sequence_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_sequence_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_sequence_timeline)>>(
          'spine_sequence_timeline_cast_to_timeline');
  late final _spine_sequence_timeline_cast_to_timeline =
      _spine_sequence_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_sequence_timeline)>();

  spine_slot_timeline spine_sequence_timeline_cast_to_slot_timeline(
    spine_sequence_timeline obj,
  ) {
    return _spine_sequence_timeline_cast_to_slot_timeline(
      obj,
    );
  }

  late final _spine_sequence_timeline_cast_to_slot_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_timeline Function(spine_sequence_timeline)>>(
          'spine_sequence_timeline_cast_to_slot_timeline');
  late final _spine_sequence_timeline_cast_to_slot_timeline = _spine_sequence_timeline_cast_to_slot_timelinePtr
      .asFunction<spine_slot_timeline Function(spine_sequence_timeline)>();

  spine_bone_timeline2 spine_shear_timeline_cast_to_bone_timeline2(
    spine_shear_timeline obj,
  ) {
    return _spine_shear_timeline_cast_to_bone_timeline2(
      obj,
    );
  }

  late final _spine_shear_timeline_cast_to_bone_timeline2Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline2 Function(spine_shear_timeline)>>(
          'spine_shear_timeline_cast_to_bone_timeline2');
  late final _spine_shear_timeline_cast_to_bone_timeline2 =
      _spine_shear_timeline_cast_to_bone_timeline2Ptr.asFunction<spine_bone_timeline2 Function(spine_shear_timeline)>();

  spine_curve_timeline spine_shear_timeline_cast_to_curve_timeline(
    spine_shear_timeline obj,
  ) {
    return _spine_shear_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_shear_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_shear_timeline)>>(
          'spine_shear_timeline_cast_to_curve_timeline');
  late final _spine_shear_timeline_cast_to_curve_timeline =
      _spine_shear_timeline_cast_to_curve_timelinePtr.asFunction<spine_curve_timeline Function(spine_shear_timeline)>();

  spine_timeline spine_shear_timeline_cast_to_timeline(
    spine_shear_timeline obj,
  ) {
    return _spine_shear_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_shear_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_shear_timeline)>>(
          'spine_shear_timeline_cast_to_timeline');
  late final _spine_shear_timeline_cast_to_timeline =
      _spine_shear_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_shear_timeline)>();

  spine_bone_timeline spine_shear_timeline_cast_to_bone_timeline(
    spine_shear_timeline obj,
  ) {
    return _spine_shear_timeline_cast_to_bone_timeline(
      obj,
    );
  }

  late final _spine_shear_timeline_cast_to_bone_timelinePtr =
      _lookup<ffi.NativeFunction<spine_bone_timeline Function(spine_shear_timeline)>>(
          'spine_shear_timeline_cast_to_bone_timeline');
  late final _spine_shear_timeline_cast_to_bone_timeline =
      _spine_shear_timeline_cast_to_bone_timelinePtr.asFunction<spine_bone_timeline Function(spine_shear_timeline)>();

  spine_bone_timeline1 spine_shear_x_timeline_cast_to_bone_timeline1(
    spine_shear_x_timeline obj,
  ) {
    return _spine_shear_x_timeline_cast_to_bone_timeline1(
      obj,
    );
  }

  late final _spine_shear_x_timeline_cast_to_bone_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline1 Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_cast_to_bone_timeline1');
  late final _spine_shear_x_timeline_cast_to_bone_timeline1 = _spine_shear_x_timeline_cast_to_bone_timeline1Ptr
      .asFunction<spine_bone_timeline1 Function(spine_shear_x_timeline)>();

  spine_curve_timeline1 spine_shear_x_timeline_cast_to_curve_timeline1(
    spine_shear_x_timeline obj,
  ) {
    return _spine_shear_x_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_shear_x_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_cast_to_curve_timeline1');
  late final _spine_shear_x_timeline_cast_to_curve_timeline1 = _spine_shear_x_timeline_cast_to_curve_timeline1Ptr
      .asFunction<spine_curve_timeline1 Function(spine_shear_x_timeline)>();

  spine_curve_timeline spine_shear_x_timeline_cast_to_curve_timeline(
    spine_shear_x_timeline obj,
  ) {
    return _spine_shear_x_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_shear_x_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_cast_to_curve_timeline');
  late final _spine_shear_x_timeline_cast_to_curve_timeline = _spine_shear_x_timeline_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_shear_x_timeline)>();

  spine_timeline spine_shear_x_timeline_cast_to_timeline(
    spine_shear_x_timeline obj,
  ) {
    return _spine_shear_x_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_shear_x_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_cast_to_timeline');
  late final _spine_shear_x_timeline_cast_to_timeline =
      _spine_shear_x_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_shear_x_timeline)>();

  spine_bone_timeline spine_shear_x_timeline_cast_to_bone_timeline(
    spine_shear_x_timeline obj,
  ) {
    return _spine_shear_x_timeline_cast_to_bone_timeline(
      obj,
    );
  }

  late final _spine_shear_x_timeline_cast_to_bone_timelinePtr =
      _lookup<ffi.NativeFunction<spine_bone_timeline Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_cast_to_bone_timeline');
  late final _spine_shear_x_timeline_cast_to_bone_timeline = _spine_shear_x_timeline_cast_to_bone_timelinePtr
      .asFunction<spine_bone_timeline Function(spine_shear_x_timeline)>();

  spine_bone_timeline1 spine_shear_y_timeline_cast_to_bone_timeline1(
    spine_shear_y_timeline obj,
  ) {
    return _spine_shear_y_timeline_cast_to_bone_timeline1(
      obj,
    );
  }

  late final _spine_shear_y_timeline_cast_to_bone_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline1 Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_cast_to_bone_timeline1');
  late final _spine_shear_y_timeline_cast_to_bone_timeline1 = _spine_shear_y_timeline_cast_to_bone_timeline1Ptr
      .asFunction<spine_bone_timeline1 Function(spine_shear_y_timeline)>();

  spine_curve_timeline1 spine_shear_y_timeline_cast_to_curve_timeline1(
    spine_shear_y_timeline obj,
  ) {
    return _spine_shear_y_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_shear_y_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_cast_to_curve_timeline1');
  late final _spine_shear_y_timeline_cast_to_curve_timeline1 = _spine_shear_y_timeline_cast_to_curve_timeline1Ptr
      .asFunction<spine_curve_timeline1 Function(spine_shear_y_timeline)>();

  spine_curve_timeline spine_shear_y_timeline_cast_to_curve_timeline(
    spine_shear_y_timeline obj,
  ) {
    return _spine_shear_y_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_shear_y_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_cast_to_curve_timeline');
  late final _spine_shear_y_timeline_cast_to_curve_timeline = _spine_shear_y_timeline_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_shear_y_timeline)>();

  spine_timeline spine_shear_y_timeline_cast_to_timeline(
    spine_shear_y_timeline obj,
  ) {
    return _spine_shear_y_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_shear_y_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_cast_to_timeline');
  late final _spine_shear_y_timeline_cast_to_timeline =
      _spine_shear_y_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_shear_y_timeline)>();

  spine_bone_timeline spine_shear_y_timeline_cast_to_bone_timeline(
    spine_shear_y_timeline obj,
  ) {
    return _spine_shear_y_timeline_cast_to_bone_timeline(
      obj,
    );
  }

  late final _spine_shear_y_timeline_cast_to_bone_timelinePtr =
      _lookup<ffi.NativeFunction<spine_bone_timeline Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_cast_to_bone_timeline');
  late final _spine_shear_y_timeline_cast_to_bone_timeline = _spine_shear_y_timeline_cast_to_bone_timelinePtr
      .asFunction<spine_bone_timeline Function(spine_shear_y_timeline)>();

  spine_slider_base spine_slider_cast_to_slider_base(
    spine_slider obj,
  ) {
    return _spine_slider_cast_to_slider_base(
      obj,
    );
  }

  late final _spine_slider_cast_to_slider_basePtr =
      _lookup<ffi.NativeFunction<spine_slider_base Function(spine_slider)>>('spine_slider_cast_to_slider_base');
  late final _spine_slider_cast_to_slider_base =
      _spine_slider_cast_to_slider_basePtr.asFunction<spine_slider_base Function(spine_slider)>();

  spine_posed spine_slider_cast_to_posed(
    spine_slider obj,
  ) {
    return _spine_slider_cast_to_posed(
      obj,
    );
  }

  late final _spine_slider_cast_to_posedPtr =
      _lookup<ffi.NativeFunction<spine_posed Function(spine_slider)>>('spine_slider_cast_to_posed');
  late final _spine_slider_cast_to_posed =
      _spine_slider_cast_to_posedPtr.asFunction<spine_posed Function(spine_slider)>();

  spine_posed_active spine_slider_cast_to_posed_active(
    spine_slider obj,
  ) {
    return _spine_slider_cast_to_posed_active(
      obj,
    );
  }

  late final _spine_slider_cast_to_posed_activePtr =
      _lookup<ffi.NativeFunction<spine_posed_active Function(spine_slider)>>('spine_slider_cast_to_posed_active');
  late final _spine_slider_cast_to_posed_active =
      _spine_slider_cast_to_posed_activePtr.asFunction<spine_posed_active Function(spine_slider)>();

  spine_constraint spine_slider_cast_to_constraint(
    spine_slider obj,
  ) {
    return _spine_slider_cast_to_constraint(
      obj,
    );
  }

  late final _spine_slider_cast_to_constraintPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_slider)>>('spine_slider_cast_to_constraint');
  late final _spine_slider_cast_to_constraint =
      _spine_slider_cast_to_constraintPtr.asFunction<spine_constraint Function(spine_slider)>();

  spine_update spine_slider_cast_to_update(
    spine_slider obj,
  ) {
    return _spine_slider_cast_to_update(
      obj,
    );
  }

  late final _spine_slider_cast_to_updatePtr =
      _lookup<ffi.NativeFunction<spine_update Function(spine_slider)>>('spine_slider_cast_to_update');
  late final _spine_slider_cast_to_update =
      _spine_slider_cast_to_updatePtr.asFunction<spine_update Function(spine_slider)>();

  spine_posed spine_slider_base_cast_to_posed(
    spine_slider_base obj,
  ) {
    return _spine_slider_base_cast_to_posed(
      obj,
    );
  }

  late final _spine_slider_base_cast_to_posedPtr =
      _lookup<ffi.NativeFunction<spine_posed Function(spine_slider_base)>>('spine_slider_base_cast_to_posed');
  late final _spine_slider_base_cast_to_posed =
      _spine_slider_base_cast_to_posedPtr.asFunction<spine_posed Function(spine_slider_base)>();

  spine_posed_active spine_slider_base_cast_to_posed_active(
    spine_slider_base obj,
  ) {
    return _spine_slider_base_cast_to_posed_active(
      obj,
    );
  }

  late final _spine_slider_base_cast_to_posed_activePtr =
      _lookup<ffi.NativeFunction<spine_posed_active Function(spine_slider_base)>>(
          'spine_slider_base_cast_to_posed_active');
  late final _spine_slider_base_cast_to_posed_active =
      _spine_slider_base_cast_to_posed_activePtr.asFunction<spine_posed_active Function(spine_slider_base)>();

  spine_constraint spine_slider_base_cast_to_constraint(
    spine_slider_base obj,
  ) {
    return _spine_slider_base_cast_to_constraint(
      obj,
    );
  }

  late final _spine_slider_base_cast_to_constraintPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_slider_base)>>('spine_slider_base_cast_to_constraint');
  late final _spine_slider_base_cast_to_constraint =
      _spine_slider_base_cast_to_constraintPtr.asFunction<spine_constraint Function(spine_slider_base)>();

  spine_update spine_slider_base_cast_to_update(
    spine_slider_base obj,
  ) {
    return _spine_slider_base_cast_to_update(
      obj,
    );
  }

  late final _spine_slider_base_cast_to_updatePtr =
      _lookup<ffi.NativeFunction<spine_update Function(spine_slider_base)>>('spine_slider_base_cast_to_update');
  late final _spine_slider_base_cast_to_update =
      _spine_slider_base_cast_to_updatePtr.asFunction<spine_update Function(spine_slider_base)>();

  spine_posed_data spine_slider_data_cast_to_posed_data(
    spine_slider_data obj,
  ) {
    return _spine_slider_data_cast_to_posed_data(
      obj,
    );
  }

  late final _spine_slider_data_cast_to_posed_dataPtr =
      _lookup<ffi.NativeFunction<spine_posed_data Function(spine_slider_data)>>('spine_slider_data_cast_to_posed_data');
  late final _spine_slider_data_cast_to_posed_data =
      _spine_slider_data_cast_to_posed_dataPtr.asFunction<spine_posed_data Function(spine_slider_data)>();

  spine_constraint_data spine_slider_data_cast_to_constraint_data(
    spine_slider_data obj,
  ) {
    return _spine_slider_data_cast_to_constraint_data(
      obj,
    );
  }

  late final _spine_slider_data_cast_to_constraint_dataPtr =
      _lookup<ffi.NativeFunction<spine_constraint_data Function(spine_slider_data)>>(
          'spine_slider_data_cast_to_constraint_data');
  late final _spine_slider_data_cast_to_constraint_data =
      _spine_slider_data_cast_to_constraint_dataPtr.asFunction<spine_constraint_data Function(spine_slider_data)>();

  spine_constraint_timeline1 spine_slider_mix_timeline_cast_to_constraint_timeline1(
    spine_slider_mix_timeline obj,
  ) {
    return _spine_slider_mix_timeline_cast_to_constraint_timeline1(
      obj,
    );
  }

  late final _spine_slider_mix_timeline_cast_to_constraint_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline1 Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_cast_to_constraint_timeline1');
  late final _spine_slider_mix_timeline_cast_to_constraint_timeline1 =
      _spine_slider_mix_timeline_cast_to_constraint_timeline1Ptr
          .asFunction<spine_constraint_timeline1 Function(spine_slider_mix_timeline)>();

  spine_curve_timeline1 spine_slider_mix_timeline_cast_to_curve_timeline1(
    spine_slider_mix_timeline obj,
  ) {
    return _spine_slider_mix_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_slider_mix_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_cast_to_curve_timeline1');
  late final _spine_slider_mix_timeline_cast_to_curve_timeline1 = _spine_slider_mix_timeline_cast_to_curve_timeline1Ptr
      .asFunction<spine_curve_timeline1 Function(spine_slider_mix_timeline)>();

  spine_curve_timeline spine_slider_mix_timeline_cast_to_curve_timeline(
    spine_slider_mix_timeline obj,
  ) {
    return _spine_slider_mix_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_slider_mix_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_cast_to_curve_timeline');
  late final _spine_slider_mix_timeline_cast_to_curve_timeline = _spine_slider_mix_timeline_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_slider_mix_timeline)>();

  spine_timeline spine_slider_mix_timeline_cast_to_timeline(
    spine_slider_mix_timeline obj,
  ) {
    return _spine_slider_mix_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_slider_mix_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_cast_to_timeline');
  late final _spine_slider_mix_timeline_cast_to_timeline =
      _spine_slider_mix_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_slider_mix_timeline)>();

  spine_constraint_timeline spine_slider_mix_timeline_cast_to_constraint_timeline(
    spine_slider_mix_timeline obj,
  ) {
    return _spine_slider_mix_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_slider_mix_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_cast_to_constraint_timeline');
  late final _spine_slider_mix_timeline_cast_to_constraint_timeline =
      _spine_slider_mix_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_slider_mix_timeline)>();

  spine_constraint_timeline1 spine_slider_timeline_cast_to_constraint_timeline1(
    spine_slider_timeline obj,
  ) {
    return _spine_slider_timeline_cast_to_constraint_timeline1(
      obj,
    );
  }

  late final _spine_slider_timeline_cast_to_constraint_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline1 Function(spine_slider_timeline)>>(
          'spine_slider_timeline_cast_to_constraint_timeline1');
  late final _spine_slider_timeline_cast_to_constraint_timeline1 =
      _spine_slider_timeline_cast_to_constraint_timeline1Ptr
          .asFunction<spine_constraint_timeline1 Function(spine_slider_timeline)>();

  spine_curve_timeline1 spine_slider_timeline_cast_to_curve_timeline1(
    spine_slider_timeline obj,
  ) {
    return _spine_slider_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_slider_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_slider_timeline)>>(
          'spine_slider_timeline_cast_to_curve_timeline1');
  late final _spine_slider_timeline_cast_to_curve_timeline1 = _spine_slider_timeline_cast_to_curve_timeline1Ptr
      .asFunction<spine_curve_timeline1 Function(spine_slider_timeline)>();

  spine_curve_timeline spine_slider_timeline_cast_to_curve_timeline(
    spine_slider_timeline obj,
  ) {
    return _spine_slider_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_slider_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_slider_timeline)>>(
          'spine_slider_timeline_cast_to_curve_timeline');
  late final _spine_slider_timeline_cast_to_curve_timeline = _spine_slider_timeline_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_slider_timeline)>();

  spine_timeline spine_slider_timeline_cast_to_timeline(
    spine_slider_timeline obj,
  ) {
    return _spine_slider_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_slider_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_slider_timeline)>>(
          'spine_slider_timeline_cast_to_timeline');
  late final _spine_slider_timeline_cast_to_timeline =
      _spine_slider_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_slider_timeline)>();

  spine_constraint_timeline spine_slider_timeline_cast_to_constraint_timeline(
    spine_slider_timeline obj,
  ) {
    return _spine_slider_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_slider_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_slider_timeline)>>(
          'spine_slider_timeline_cast_to_constraint_timeline');
  late final _spine_slider_timeline_cast_to_constraint_timeline = _spine_slider_timeline_cast_to_constraint_timelinePtr
      .asFunction<spine_constraint_timeline Function(spine_slider_timeline)>();

  spine_posed spine_slot_cast_to_posed(
    spine_slot obj,
  ) {
    return _spine_slot_cast_to_posed(
      obj,
    );
  }

  late final _spine_slot_cast_to_posedPtr =
      _lookup<ffi.NativeFunction<spine_posed Function(spine_slot)>>('spine_slot_cast_to_posed');
  late final _spine_slot_cast_to_posed = _spine_slot_cast_to_posedPtr.asFunction<spine_posed Function(spine_slot)>();

  spine_curve_timeline spine_slot_curve_timeline_cast_to_curve_timeline(
    spine_slot_curve_timeline obj,
  ) {
    return _spine_slot_curve_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_slot_curve_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_cast_to_curve_timeline');
  late final _spine_slot_curve_timeline_cast_to_curve_timeline = _spine_slot_curve_timeline_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_slot_curve_timeline)>();

  spine_timeline spine_slot_curve_timeline_cast_to_timeline(
    spine_slot_curve_timeline obj,
  ) {
    return _spine_slot_curve_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_slot_curve_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_cast_to_timeline');
  late final _spine_slot_curve_timeline_cast_to_timeline =
      _spine_slot_curve_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_slot_curve_timeline)>();

  spine_slot_timeline spine_slot_curve_timeline_cast_to_slot_timeline(
    spine_slot_curve_timeline obj,
  ) {
    return _spine_slot_curve_timeline_cast_to_slot_timeline(
      obj,
    );
  }

  late final _spine_slot_curve_timeline_cast_to_slot_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_timeline Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_cast_to_slot_timeline');
  late final _spine_slot_curve_timeline_cast_to_slot_timeline = _spine_slot_curve_timeline_cast_to_slot_timelinePtr
      .asFunction<spine_slot_timeline Function(spine_slot_curve_timeline)>();

  spine_posed_data spine_slot_data_cast_to_posed_data(
    spine_slot_data obj,
  ) {
    return _spine_slot_data_cast_to_posed_data(
      obj,
    );
  }

  late final _spine_slot_data_cast_to_posed_dataPtr =
      _lookup<ffi.NativeFunction<spine_posed_data Function(spine_slot_data)>>('spine_slot_data_cast_to_posed_data');
  late final _spine_slot_data_cast_to_posed_data =
      _spine_slot_data_cast_to_posed_dataPtr.asFunction<spine_posed_data Function(spine_slot_data)>();

  spine_to_property spine_to_rotate_cast_to_to_property(
    spine_to_rotate obj,
  ) {
    return _spine_to_rotate_cast_to_to_property(
      obj,
    );
  }

  late final _spine_to_rotate_cast_to_to_propertyPtr =
      _lookup<ffi.NativeFunction<spine_to_property Function(spine_to_rotate)>>('spine_to_rotate_cast_to_to_property');
  late final _spine_to_rotate_cast_to_to_property =
      _spine_to_rotate_cast_to_to_propertyPtr.asFunction<spine_to_property Function(spine_to_rotate)>();

  spine_to_property spine_to_scale_x_cast_to_to_property(
    spine_to_scale_x obj,
  ) {
    return _spine_to_scale_x_cast_to_to_property(
      obj,
    );
  }

  late final _spine_to_scale_x_cast_to_to_propertyPtr =
      _lookup<ffi.NativeFunction<spine_to_property Function(spine_to_scale_x)>>('spine_to_scale_x_cast_to_to_property');
  late final _spine_to_scale_x_cast_to_to_property =
      _spine_to_scale_x_cast_to_to_propertyPtr.asFunction<spine_to_property Function(spine_to_scale_x)>();

  spine_to_property spine_to_scale_y_cast_to_to_property(
    spine_to_scale_y obj,
  ) {
    return _spine_to_scale_y_cast_to_to_property(
      obj,
    );
  }

  late final _spine_to_scale_y_cast_to_to_propertyPtr =
      _lookup<ffi.NativeFunction<spine_to_property Function(spine_to_scale_y)>>('spine_to_scale_y_cast_to_to_property');
  late final _spine_to_scale_y_cast_to_to_property =
      _spine_to_scale_y_cast_to_to_propertyPtr.asFunction<spine_to_property Function(spine_to_scale_y)>();

  spine_to_property spine_to_shear_y_cast_to_to_property(
    spine_to_shear_y obj,
  ) {
    return _spine_to_shear_y_cast_to_to_property(
      obj,
    );
  }

  late final _spine_to_shear_y_cast_to_to_propertyPtr =
      _lookup<ffi.NativeFunction<spine_to_property Function(spine_to_shear_y)>>('spine_to_shear_y_cast_to_to_property');
  late final _spine_to_shear_y_cast_to_to_property =
      _spine_to_shear_y_cast_to_to_propertyPtr.asFunction<spine_to_property Function(spine_to_shear_y)>();

  spine_to_property spine_to_x_cast_to_to_property(
    spine_to_x obj,
  ) {
    return _spine_to_x_cast_to_to_property(
      obj,
    );
  }

  late final _spine_to_x_cast_to_to_propertyPtr =
      _lookup<ffi.NativeFunction<spine_to_property Function(spine_to_x)>>('spine_to_x_cast_to_to_property');
  late final _spine_to_x_cast_to_to_property =
      _spine_to_x_cast_to_to_propertyPtr.asFunction<spine_to_property Function(spine_to_x)>();

  spine_to_property spine_to_y_cast_to_to_property(
    spine_to_y obj,
  ) {
    return _spine_to_y_cast_to_to_property(
      obj,
    );
  }

  late final _spine_to_y_cast_to_to_propertyPtr =
      _lookup<ffi.NativeFunction<spine_to_property Function(spine_to_y)>>('spine_to_y_cast_to_to_property');
  late final _spine_to_y_cast_to_to_property =
      _spine_to_y_cast_to_to_propertyPtr.asFunction<spine_to_property Function(spine_to_y)>();

  spine_transform_constraint_base spine_transform_constraint_cast_to_transform_constraint_base(
    spine_transform_constraint obj,
  ) {
    return _spine_transform_constraint_cast_to_transform_constraint_base(
      obj,
    );
  }

  late final _spine_transform_constraint_cast_to_transform_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_base Function(spine_transform_constraint)>>(
          'spine_transform_constraint_cast_to_transform_constraint_base');
  late final _spine_transform_constraint_cast_to_transform_constraint_base =
      _spine_transform_constraint_cast_to_transform_constraint_basePtr
          .asFunction<spine_transform_constraint_base Function(spine_transform_constraint)>();

  spine_posed spine_transform_constraint_cast_to_posed(
    spine_transform_constraint obj,
  ) {
    return _spine_transform_constraint_cast_to_posed(
      obj,
    );
  }

  late final _spine_transform_constraint_cast_to_posedPtr =
      _lookup<ffi.NativeFunction<spine_posed Function(spine_transform_constraint)>>(
          'spine_transform_constraint_cast_to_posed');
  late final _spine_transform_constraint_cast_to_posed =
      _spine_transform_constraint_cast_to_posedPtr.asFunction<spine_posed Function(spine_transform_constraint)>();

  spine_posed_active spine_transform_constraint_cast_to_posed_active(
    spine_transform_constraint obj,
  ) {
    return _spine_transform_constraint_cast_to_posed_active(
      obj,
    );
  }

  late final _spine_transform_constraint_cast_to_posed_activePtr =
      _lookup<ffi.NativeFunction<spine_posed_active Function(spine_transform_constraint)>>(
          'spine_transform_constraint_cast_to_posed_active');
  late final _spine_transform_constraint_cast_to_posed_active = _spine_transform_constraint_cast_to_posed_activePtr
      .asFunction<spine_posed_active Function(spine_transform_constraint)>();

  spine_constraint spine_transform_constraint_cast_to_constraint(
    spine_transform_constraint obj,
  ) {
    return _spine_transform_constraint_cast_to_constraint(
      obj,
    );
  }

  late final _spine_transform_constraint_cast_to_constraintPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_transform_constraint)>>(
          'spine_transform_constraint_cast_to_constraint');
  late final _spine_transform_constraint_cast_to_constraint = _spine_transform_constraint_cast_to_constraintPtr
      .asFunction<spine_constraint Function(spine_transform_constraint)>();

  spine_update spine_transform_constraint_cast_to_update(
    spine_transform_constraint obj,
  ) {
    return _spine_transform_constraint_cast_to_update(
      obj,
    );
  }

  late final _spine_transform_constraint_cast_to_updatePtr =
      _lookup<ffi.NativeFunction<spine_update Function(spine_transform_constraint)>>(
          'spine_transform_constraint_cast_to_update');
  late final _spine_transform_constraint_cast_to_update =
      _spine_transform_constraint_cast_to_updatePtr.asFunction<spine_update Function(spine_transform_constraint)>();

  spine_posed spine_transform_constraint_base_cast_to_posed(
    spine_transform_constraint_base obj,
  ) {
    return _spine_transform_constraint_base_cast_to_posed(
      obj,
    );
  }

  late final _spine_transform_constraint_base_cast_to_posedPtr =
      _lookup<ffi.NativeFunction<spine_posed Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_cast_to_posed');
  late final _spine_transform_constraint_base_cast_to_posed = _spine_transform_constraint_base_cast_to_posedPtr
      .asFunction<spine_posed Function(spine_transform_constraint_base)>();

  spine_posed_active spine_transform_constraint_base_cast_to_posed_active(
    spine_transform_constraint_base obj,
  ) {
    return _spine_transform_constraint_base_cast_to_posed_active(
      obj,
    );
  }

  late final _spine_transform_constraint_base_cast_to_posed_activePtr =
      _lookup<ffi.NativeFunction<spine_posed_active Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_cast_to_posed_active');
  late final _spine_transform_constraint_base_cast_to_posed_active =
      _spine_transform_constraint_base_cast_to_posed_activePtr
          .asFunction<spine_posed_active Function(spine_transform_constraint_base)>();

  spine_constraint spine_transform_constraint_base_cast_to_constraint(
    spine_transform_constraint_base obj,
  ) {
    return _spine_transform_constraint_base_cast_to_constraint(
      obj,
    );
  }

  late final _spine_transform_constraint_base_cast_to_constraintPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_cast_to_constraint');
  late final _spine_transform_constraint_base_cast_to_constraint =
      _spine_transform_constraint_base_cast_to_constraintPtr
          .asFunction<spine_constraint Function(spine_transform_constraint_base)>();

  spine_update spine_transform_constraint_base_cast_to_update(
    spine_transform_constraint_base obj,
  ) {
    return _spine_transform_constraint_base_cast_to_update(
      obj,
    );
  }

  late final _spine_transform_constraint_base_cast_to_updatePtr =
      _lookup<ffi.NativeFunction<spine_update Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_cast_to_update');
  late final _spine_transform_constraint_base_cast_to_update = _spine_transform_constraint_base_cast_to_updatePtr
      .asFunction<spine_update Function(spine_transform_constraint_base)>();

  spine_posed_data spine_transform_constraint_data_cast_to_posed_data(
    spine_transform_constraint_data obj,
  ) {
    return _spine_transform_constraint_data_cast_to_posed_data(
      obj,
    );
  }

  late final _spine_transform_constraint_data_cast_to_posed_dataPtr =
      _lookup<ffi.NativeFunction<spine_posed_data Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_cast_to_posed_data');
  late final _spine_transform_constraint_data_cast_to_posed_data =
      _spine_transform_constraint_data_cast_to_posed_dataPtr
          .asFunction<spine_posed_data Function(spine_transform_constraint_data)>();

  spine_constraint_data spine_transform_constraint_data_cast_to_constraint_data(
    spine_transform_constraint_data obj,
  ) {
    return _spine_transform_constraint_data_cast_to_constraint_data(
      obj,
    );
  }

  late final _spine_transform_constraint_data_cast_to_constraint_dataPtr =
      _lookup<ffi.NativeFunction<spine_constraint_data Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_cast_to_constraint_data');
  late final _spine_transform_constraint_data_cast_to_constraint_data =
      _spine_transform_constraint_data_cast_to_constraint_dataPtr
          .asFunction<spine_constraint_data Function(spine_transform_constraint_data)>();

  spine_curve_timeline spine_transform_constraint_timeline_cast_to_curve_timeline(
    spine_transform_constraint_timeline obj,
  ) {
    return _spine_transform_constraint_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_transform_constraint_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_cast_to_curve_timeline');
  late final _spine_transform_constraint_timeline_cast_to_curve_timeline =
      _spine_transform_constraint_timeline_cast_to_curve_timelinePtr
          .asFunction<spine_curve_timeline Function(spine_transform_constraint_timeline)>();

  spine_timeline spine_transform_constraint_timeline_cast_to_timeline(
    spine_transform_constraint_timeline obj,
  ) {
    return _spine_transform_constraint_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_transform_constraint_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_cast_to_timeline');
  late final _spine_transform_constraint_timeline_cast_to_timeline =
      _spine_transform_constraint_timeline_cast_to_timelinePtr
          .asFunction<spine_timeline Function(spine_transform_constraint_timeline)>();

  spine_constraint_timeline spine_transform_constraint_timeline_cast_to_constraint_timeline(
    spine_transform_constraint_timeline obj,
  ) {
    return _spine_transform_constraint_timeline_cast_to_constraint_timeline(
      obj,
    );
  }

  late final _spine_transform_constraint_timeline_cast_to_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_cast_to_constraint_timeline');
  late final _spine_transform_constraint_timeline_cast_to_constraint_timeline =
      _spine_transform_constraint_timeline_cast_to_constraint_timelinePtr
          .asFunction<spine_constraint_timeline Function(spine_transform_constraint_timeline)>();

  spine_bone_timeline2 spine_translate_timeline_cast_to_bone_timeline2(
    spine_translate_timeline obj,
  ) {
    return _spine_translate_timeline_cast_to_bone_timeline2(
      obj,
    );
  }

  late final _spine_translate_timeline_cast_to_bone_timeline2Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline2 Function(spine_translate_timeline)>>(
          'spine_translate_timeline_cast_to_bone_timeline2');
  late final _spine_translate_timeline_cast_to_bone_timeline2 = _spine_translate_timeline_cast_to_bone_timeline2Ptr
      .asFunction<spine_bone_timeline2 Function(spine_translate_timeline)>();

  spine_curve_timeline spine_translate_timeline_cast_to_curve_timeline(
    spine_translate_timeline obj,
  ) {
    return _spine_translate_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_translate_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_translate_timeline)>>(
          'spine_translate_timeline_cast_to_curve_timeline');
  late final _spine_translate_timeline_cast_to_curve_timeline = _spine_translate_timeline_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_translate_timeline)>();

  spine_timeline spine_translate_timeline_cast_to_timeline(
    spine_translate_timeline obj,
  ) {
    return _spine_translate_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_translate_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_translate_timeline)>>(
          'spine_translate_timeline_cast_to_timeline');
  late final _spine_translate_timeline_cast_to_timeline =
      _spine_translate_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_translate_timeline)>();

  spine_bone_timeline spine_translate_timeline_cast_to_bone_timeline(
    spine_translate_timeline obj,
  ) {
    return _spine_translate_timeline_cast_to_bone_timeline(
      obj,
    );
  }

  late final _spine_translate_timeline_cast_to_bone_timelinePtr =
      _lookup<ffi.NativeFunction<spine_bone_timeline Function(spine_translate_timeline)>>(
          'spine_translate_timeline_cast_to_bone_timeline');
  late final _spine_translate_timeline_cast_to_bone_timeline = _spine_translate_timeline_cast_to_bone_timelinePtr
      .asFunction<spine_bone_timeline Function(spine_translate_timeline)>();

  spine_bone_timeline1 spine_translate_x_timeline_cast_to_bone_timeline1(
    spine_translate_x_timeline obj,
  ) {
    return _spine_translate_x_timeline_cast_to_bone_timeline1(
      obj,
    );
  }

  late final _spine_translate_x_timeline_cast_to_bone_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline1 Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_cast_to_bone_timeline1');
  late final _spine_translate_x_timeline_cast_to_bone_timeline1 = _spine_translate_x_timeline_cast_to_bone_timeline1Ptr
      .asFunction<spine_bone_timeline1 Function(spine_translate_x_timeline)>();

  spine_curve_timeline1 spine_translate_x_timeline_cast_to_curve_timeline1(
    spine_translate_x_timeline obj,
  ) {
    return _spine_translate_x_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_translate_x_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_cast_to_curve_timeline1');
  late final _spine_translate_x_timeline_cast_to_curve_timeline1 =
      _spine_translate_x_timeline_cast_to_curve_timeline1Ptr
          .asFunction<spine_curve_timeline1 Function(spine_translate_x_timeline)>();

  spine_curve_timeline spine_translate_x_timeline_cast_to_curve_timeline(
    spine_translate_x_timeline obj,
  ) {
    return _spine_translate_x_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_translate_x_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_cast_to_curve_timeline');
  late final _spine_translate_x_timeline_cast_to_curve_timeline = _spine_translate_x_timeline_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_translate_x_timeline)>();

  spine_timeline spine_translate_x_timeline_cast_to_timeline(
    spine_translate_x_timeline obj,
  ) {
    return _spine_translate_x_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_translate_x_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_cast_to_timeline');
  late final _spine_translate_x_timeline_cast_to_timeline =
      _spine_translate_x_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_translate_x_timeline)>();

  spine_bone_timeline spine_translate_x_timeline_cast_to_bone_timeline(
    spine_translate_x_timeline obj,
  ) {
    return _spine_translate_x_timeline_cast_to_bone_timeline(
      obj,
    );
  }

  late final _spine_translate_x_timeline_cast_to_bone_timelinePtr =
      _lookup<ffi.NativeFunction<spine_bone_timeline Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_cast_to_bone_timeline');
  late final _spine_translate_x_timeline_cast_to_bone_timeline = _spine_translate_x_timeline_cast_to_bone_timelinePtr
      .asFunction<spine_bone_timeline Function(spine_translate_x_timeline)>();

  spine_bone_timeline1 spine_translate_y_timeline_cast_to_bone_timeline1(
    spine_translate_y_timeline obj,
  ) {
    return _spine_translate_y_timeline_cast_to_bone_timeline1(
      obj,
    );
  }

  late final _spine_translate_y_timeline_cast_to_bone_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline1 Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_cast_to_bone_timeline1');
  late final _spine_translate_y_timeline_cast_to_bone_timeline1 = _spine_translate_y_timeline_cast_to_bone_timeline1Ptr
      .asFunction<spine_bone_timeline1 Function(spine_translate_y_timeline)>();

  spine_curve_timeline1 spine_translate_y_timeline_cast_to_curve_timeline1(
    spine_translate_y_timeline obj,
  ) {
    return _spine_translate_y_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_translate_y_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_cast_to_curve_timeline1');
  late final _spine_translate_y_timeline_cast_to_curve_timeline1 =
      _spine_translate_y_timeline_cast_to_curve_timeline1Ptr
          .asFunction<spine_curve_timeline1 Function(spine_translate_y_timeline)>();

  spine_curve_timeline spine_translate_y_timeline_cast_to_curve_timeline(
    spine_translate_y_timeline obj,
  ) {
    return _spine_translate_y_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_translate_y_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_cast_to_curve_timeline');
  late final _spine_translate_y_timeline_cast_to_curve_timeline = _spine_translate_y_timeline_cast_to_curve_timelinePtr
      .asFunction<spine_curve_timeline Function(spine_translate_y_timeline)>();

  spine_timeline spine_translate_y_timeline_cast_to_timeline(
    spine_translate_y_timeline obj,
  ) {
    return _spine_translate_y_timeline_cast_to_timeline(
      obj,
    );
  }

  late final _spine_translate_y_timeline_cast_to_timelinePtr =
      _lookup<ffi.NativeFunction<spine_timeline Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_cast_to_timeline');
  late final _spine_translate_y_timeline_cast_to_timeline =
      _spine_translate_y_timeline_cast_to_timelinePtr.asFunction<spine_timeline Function(spine_translate_y_timeline)>();

  spine_bone_timeline spine_translate_y_timeline_cast_to_bone_timeline(
    spine_translate_y_timeline obj,
  ) {
    return _spine_translate_y_timeline_cast_to_bone_timeline(
      obj,
    );
  }

  late final _spine_translate_y_timeline_cast_to_bone_timelinePtr =
      _lookup<ffi.NativeFunction<spine_bone_timeline Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_cast_to_bone_timeline');
  late final _spine_translate_y_timeline_cast_to_bone_timeline = _spine_translate_y_timeline_cast_to_bone_timelinePtr
      .asFunction<spine_bone_timeline Function(spine_translate_y_timeline)>();

  spine_attachment spine_vertex_attachment_cast_to_attachment(
    spine_vertex_attachment obj,
  ) {
    return _spine_vertex_attachment_cast_to_attachment(
      obj,
    );
  }

  late final _spine_vertex_attachment_cast_to_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_cast_to_attachment');
  late final _spine_vertex_attachment_cast_to_attachment =
      _spine_vertex_attachment_cast_to_attachmentPtr.asFunction<spine_attachment Function(spine_vertex_attachment)>();

  /// Downcast functions (base to derived) - user must ensure correct type
  spine_alpha_timeline spine_curve_timeline1_cast_to_alpha_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_alpha_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_alpha_timelinePtr =
      _lookup<ffi.NativeFunction<spine_alpha_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_alpha_timeline');
  late final _spine_curve_timeline1_cast_to_alpha_timeline = _spine_curve_timeline1_cast_to_alpha_timelinePtr
      .asFunction<spine_alpha_timeline Function(spine_curve_timeline1)>();

  spine_bone_timeline1 spine_curve_timeline1_cast_to_bone_timeline1(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_bone_timeline1(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_bone_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline1 Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_bone_timeline1');
  late final _spine_curve_timeline1_cast_to_bone_timeline1 = _spine_curve_timeline1_cast_to_bone_timeline1Ptr
      .asFunction<spine_bone_timeline1 Function(spine_curve_timeline1)>();

  spine_constraint_timeline1 spine_curve_timeline1_cast_to_constraint_timeline1(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_constraint_timeline1(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_constraint_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline1 Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_constraint_timeline1');
  late final _spine_curve_timeline1_cast_to_constraint_timeline1 =
      _spine_curve_timeline1_cast_to_constraint_timeline1Ptr
          .asFunction<spine_constraint_timeline1 Function(spine_curve_timeline1)>();

  spine_path_constraint_position_timeline spine_curve_timeline1_cast_to_path_constraint_position_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_path_constraint_position_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_path_constraint_position_timelinePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_position_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_path_constraint_position_timeline');
  late final _spine_curve_timeline1_cast_to_path_constraint_position_timeline =
      _spine_curve_timeline1_cast_to_path_constraint_position_timelinePtr
          .asFunction<spine_path_constraint_position_timeline Function(spine_curve_timeline1)>();

  spine_path_constraint_spacing_timeline spine_curve_timeline1_cast_to_path_constraint_spacing_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_path_constraint_spacing_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_path_constraint_spacing_timelinePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_spacing_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_path_constraint_spacing_timeline');
  late final _spine_curve_timeline1_cast_to_path_constraint_spacing_timeline =
      _spine_curve_timeline1_cast_to_path_constraint_spacing_timelinePtr
          .asFunction<spine_path_constraint_spacing_timeline Function(spine_curve_timeline1)>();

  spine_physics_constraint_damping_timeline spine_curve_timeline1_cast_to_physics_constraint_damping_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_physics_constraint_damping_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_physics_constraint_damping_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_damping_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_physics_constraint_damping_timeline');
  late final _spine_curve_timeline1_cast_to_physics_constraint_damping_timeline =
      _spine_curve_timeline1_cast_to_physics_constraint_damping_timelinePtr
          .asFunction<spine_physics_constraint_damping_timeline Function(spine_curve_timeline1)>();

  spine_physics_constraint_gravity_timeline spine_curve_timeline1_cast_to_physics_constraint_gravity_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_physics_constraint_gravity_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_physics_constraint_gravity_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_gravity_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_physics_constraint_gravity_timeline');
  late final _spine_curve_timeline1_cast_to_physics_constraint_gravity_timeline =
      _spine_curve_timeline1_cast_to_physics_constraint_gravity_timelinePtr
          .asFunction<spine_physics_constraint_gravity_timeline Function(spine_curve_timeline1)>();

  spine_physics_constraint_inertia_timeline spine_curve_timeline1_cast_to_physics_constraint_inertia_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_physics_constraint_inertia_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_physics_constraint_inertia_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_inertia_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_physics_constraint_inertia_timeline');
  late final _spine_curve_timeline1_cast_to_physics_constraint_inertia_timeline =
      _spine_curve_timeline1_cast_to_physics_constraint_inertia_timelinePtr
          .asFunction<spine_physics_constraint_inertia_timeline Function(spine_curve_timeline1)>();

  spine_physics_constraint_mass_timeline spine_curve_timeline1_cast_to_physics_constraint_mass_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_physics_constraint_mass_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_physics_constraint_mass_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_mass_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_physics_constraint_mass_timeline');
  late final _spine_curve_timeline1_cast_to_physics_constraint_mass_timeline =
      _spine_curve_timeline1_cast_to_physics_constraint_mass_timelinePtr
          .asFunction<spine_physics_constraint_mass_timeline Function(spine_curve_timeline1)>();

  spine_physics_constraint_mix_timeline spine_curve_timeline1_cast_to_physics_constraint_mix_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_physics_constraint_mix_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_physics_constraint_mix_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_mix_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_physics_constraint_mix_timeline');
  late final _spine_curve_timeline1_cast_to_physics_constraint_mix_timeline =
      _spine_curve_timeline1_cast_to_physics_constraint_mix_timelinePtr
          .asFunction<spine_physics_constraint_mix_timeline Function(spine_curve_timeline1)>();

  spine_physics_constraint_strength_timeline spine_curve_timeline1_cast_to_physics_constraint_strength_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_physics_constraint_strength_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_physics_constraint_strength_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_strength_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_physics_constraint_strength_timeline');
  late final _spine_curve_timeline1_cast_to_physics_constraint_strength_timeline =
      _spine_curve_timeline1_cast_to_physics_constraint_strength_timelinePtr
          .asFunction<spine_physics_constraint_strength_timeline Function(spine_curve_timeline1)>();

  spine_physics_constraint_timeline spine_curve_timeline1_cast_to_physics_constraint_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_physics_constraint_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_physics_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_physics_constraint_timeline');
  late final _spine_curve_timeline1_cast_to_physics_constraint_timeline =
      _spine_curve_timeline1_cast_to_physics_constraint_timelinePtr
          .asFunction<spine_physics_constraint_timeline Function(spine_curve_timeline1)>();

  spine_physics_constraint_wind_timeline spine_curve_timeline1_cast_to_physics_constraint_wind_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_physics_constraint_wind_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_physics_constraint_wind_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_wind_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_physics_constraint_wind_timeline');
  late final _spine_curve_timeline1_cast_to_physics_constraint_wind_timeline =
      _spine_curve_timeline1_cast_to_physics_constraint_wind_timelinePtr
          .asFunction<spine_physics_constraint_wind_timeline Function(spine_curve_timeline1)>();

  spine_rotate_timeline spine_curve_timeline1_cast_to_rotate_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_rotate_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_rotate_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rotate_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_rotate_timeline');
  late final _spine_curve_timeline1_cast_to_rotate_timeline = _spine_curve_timeline1_cast_to_rotate_timelinePtr
      .asFunction<spine_rotate_timeline Function(spine_curve_timeline1)>();

  spine_scale_x_timeline spine_curve_timeline1_cast_to_scale_x_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_scale_x_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_scale_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_x_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_scale_x_timeline');
  late final _spine_curve_timeline1_cast_to_scale_x_timeline = _spine_curve_timeline1_cast_to_scale_x_timelinePtr
      .asFunction<spine_scale_x_timeline Function(spine_curve_timeline1)>();

  spine_scale_y_timeline spine_curve_timeline1_cast_to_scale_y_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_scale_y_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_scale_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_y_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_scale_y_timeline');
  late final _spine_curve_timeline1_cast_to_scale_y_timeline = _spine_curve_timeline1_cast_to_scale_y_timelinePtr
      .asFunction<spine_scale_y_timeline Function(spine_curve_timeline1)>();

  spine_shear_x_timeline spine_curve_timeline1_cast_to_shear_x_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_shear_x_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_shear_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_x_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_shear_x_timeline');
  late final _spine_curve_timeline1_cast_to_shear_x_timeline = _spine_curve_timeline1_cast_to_shear_x_timelinePtr
      .asFunction<spine_shear_x_timeline Function(spine_curve_timeline1)>();

  spine_shear_y_timeline spine_curve_timeline1_cast_to_shear_y_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_shear_y_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_shear_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_y_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_shear_y_timeline');
  late final _spine_curve_timeline1_cast_to_shear_y_timeline = _spine_curve_timeline1_cast_to_shear_y_timelinePtr
      .asFunction<spine_shear_y_timeline Function(spine_curve_timeline1)>();

  spine_slider_mix_timeline spine_curve_timeline1_cast_to_slider_mix_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_slider_mix_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_slider_mix_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slider_mix_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_slider_mix_timeline');
  late final _spine_curve_timeline1_cast_to_slider_mix_timeline = _spine_curve_timeline1_cast_to_slider_mix_timelinePtr
      .asFunction<spine_slider_mix_timeline Function(spine_curve_timeline1)>();

  spine_slider_timeline spine_curve_timeline1_cast_to_slider_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_slider_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_slider_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slider_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_slider_timeline');
  late final _spine_curve_timeline1_cast_to_slider_timeline = _spine_curve_timeline1_cast_to_slider_timelinePtr
      .asFunction<spine_slider_timeline Function(spine_curve_timeline1)>();

  spine_translate_x_timeline spine_curve_timeline1_cast_to_translate_x_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_translate_x_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_translate_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_x_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_translate_x_timeline');
  late final _spine_curve_timeline1_cast_to_translate_x_timeline =
      _spine_curve_timeline1_cast_to_translate_x_timelinePtr
          .asFunction<spine_translate_x_timeline Function(spine_curve_timeline1)>();

  spine_translate_y_timeline spine_curve_timeline1_cast_to_translate_y_timeline(
    spine_curve_timeline1 obj,
  ) {
    return _spine_curve_timeline1_cast_to_translate_y_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline1_cast_to_translate_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_y_timeline Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_cast_to_translate_y_timeline');
  late final _spine_curve_timeline1_cast_to_translate_y_timeline =
      _spine_curve_timeline1_cast_to_translate_y_timelinePtr
          .asFunction<spine_translate_y_timeline Function(spine_curve_timeline1)>();

  spine_alpha_timeline spine_curve_timeline_cast_to_alpha_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_alpha_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_alpha_timelinePtr =
      _lookup<ffi.NativeFunction<spine_alpha_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_alpha_timeline');
  late final _spine_curve_timeline_cast_to_alpha_timeline =
      _spine_curve_timeline_cast_to_alpha_timelinePtr.asFunction<spine_alpha_timeline Function(spine_curve_timeline)>();

  spine_bone_timeline1 spine_curve_timeline_cast_to_bone_timeline1(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_bone_timeline1(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_bone_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline1 Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_bone_timeline1');
  late final _spine_curve_timeline_cast_to_bone_timeline1 =
      _spine_curve_timeline_cast_to_bone_timeline1Ptr.asFunction<spine_bone_timeline1 Function(spine_curve_timeline)>();

  spine_bone_timeline2 spine_curve_timeline_cast_to_bone_timeline2(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_bone_timeline2(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_bone_timeline2Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline2 Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_bone_timeline2');
  late final _spine_curve_timeline_cast_to_bone_timeline2 =
      _spine_curve_timeline_cast_to_bone_timeline2Ptr.asFunction<spine_bone_timeline2 Function(spine_curve_timeline)>();

  spine_constraint_timeline1 spine_curve_timeline_cast_to_constraint_timeline1(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_constraint_timeline1(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_constraint_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline1 Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_constraint_timeline1');
  late final _spine_curve_timeline_cast_to_constraint_timeline1 = _spine_curve_timeline_cast_to_constraint_timeline1Ptr
      .asFunction<spine_constraint_timeline1 Function(spine_curve_timeline)>();

  spine_curve_timeline1 spine_curve_timeline_cast_to_curve_timeline1(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_curve_timeline1');
  late final _spine_curve_timeline_cast_to_curve_timeline1 = _spine_curve_timeline_cast_to_curve_timeline1Ptr
      .asFunction<spine_curve_timeline1 Function(spine_curve_timeline)>();

  spine_deform_timeline spine_curve_timeline_cast_to_deform_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_deform_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_deform_timelinePtr =
      _lookup<ffi.NativeFunction<spine_deform_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_deform_timeline');
  late final _spine_curve_timeline_cast_to_deform_timeline = _spine_curve_timeline_cast_to_deform_timelinePtr
      .asFunction<spine_deform_timeline Function(spine_curve_timeline)>();

  spine_ik_constraint_timeline spine_curve_timeline_cast_to_ik_constraint_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_ik_constraint_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_ik_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_ik_constraint_timeline');
  late final _spine_curve_timeline_cast_to_ik_constraint_timeline =
      _spine_curve_timeline_cast_to_ik_constraint_timelinePtr
          .asFunction<spine_ik_constraint_timeline Function(spine_curve_timeline)>();

  spine_path_constraint_mix_timeline spine_curve_timeline_cast_to_path_constraint_mix_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_path_constraint_mix_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_path_constraint_mix_timelinePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_mix_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_path_constraint_mix_timeline');
  late final _spine_curve_timeline_cast_to_path_constraint_mix_timeline =
      _spine_curve_timeline_cast_to_path_constraint_mix_timelinePtr
          .asFunction<spine_path_constraint_mix_timeline Function(spine_curve_timeline)>();

  spine_path_constraint_position_timeline spine_curve_timeline_cast_to_path_constraint_position_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_path_constraint_position_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_path_constraint_position_timelinePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_position_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_path_constraint_position_timeline');
  late final _spine_curve_timeline_cast_to_path_constraint_position_timeline =
      _spine_curve_timeline_cast_to_path_constraint_position_timelinePtr
          .asFunction<spine_path_constraint_position_timeline Function(spine_curve_timeline)>();

  spine_path_constraint_spacing_timeline spine_curve_timeline_cast_to_path_constraint_spacing_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_path_constraint_spacing_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_path_constraint_spacing_timelinePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_spacing_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_path_constraint_spacing_timeline');
  late final _spine_curve_timeline_cast_to_path_constraint_spacing_timeline =
      _spine_curve_timeline_cast_to_path_constraint_spacing_timelinePtr
          .asFunction<spine_path_constraint_spacing_timeline Function(spine_curve_timeline)>();

  spine_physics_constraint_damping_timeline spine_curve_timeline_cast_to_physics_constraint_damping_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_physics_constraint_damping_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_physics_constraint_damping_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_damping_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_physics_constraint_damping_timeline');
  late final _spine_curve_timeline_cast_to_physics_constraint_damping_timeline =
      _spine_curve_timeline_cast_to_physics_constraint_damping_timelinePtr
          .asFunction<spine_physics_constraint_damping_timeline Function(spine_curve_timeline)>();

  spine_physics_constraint_gravity_timeline spine_curve_timeline_cast_to_physics_constraint_gravity_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_physics_constraint_gravity_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_physics_constraint_gravity_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_gravity_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_physics_constraint_gravity_timeline');
  late final _spine_curve_timeline_cast_to_physics_constraint_gravity_timeline =
      _spine_curve_timeline_cast_to_physics_constraint_gravity_timelinePtr
          .asFunction<spine_physics_constraint_gravity_timeline Function(spine_curve_timeline)>();

  spine_physics_constraint_inertia_timeline spine_curve_timeline_cast_to_physics_constraint_inertia_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_physics_constraint_inertia_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_physics_constraint_inertia_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_inertia_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_physics_constraint_inertia_timeline');
  late final _spine_curve_timeline_cast_to_physics_constraint_inertia_timeline =
      _spine_curve_timeline_cast_to_physics_constraint_inertia_timelinePtr
          .asFunction<spine_physics_constraint_inertia_timeline Function(spine_curve_timeline)>();

  spine_physics_constraint_mass_timeline spine_curve_timeline_cast_to_physics_constraint_mass_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_physics_constraint_mass_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_physics_constraint_mass_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_mass_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_physics_constraint_mass_timeline');
  late final _spine_curve_timeline_cast_to_physics_constraint_mass_timeline =
      _spine_curve_timeline_cast_to_physics_constraint_mass_timelinePtr
          .asFunction<spine_physics_constraint_mass_timeline Function(spine_curve_timeline)>();

  spine_physics_constraint_mix_timeline spine_curve_timeline_cast_to_physics_constraint_mix_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_physics_constraint_mix_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_physics_constraint_mix_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_mix_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_physics_constraint_mix_timeline');
  late final _spine_curve_timeline_cast_to_physics_constraint_mix_timeline =
      _spine_curve_timeline_cast_to_physics_constraint_mix_timelinePtr
          .asFunction<spine_physics_constraint_mix_timeline Function(spine_curve_timeline)>();

  spine_physics_constraint_strength_timeline spine_curve_timeline_cast_to_physics_constraint_strength_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_physics_constraint_strength_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_physics_constraint_strength_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_strength_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_physics_constraint_strength_timeline');
  late final _spine_curve_timeline_cast_to_physics_constraint_strength_timeline =
      _spine_curve_timeline_cast_to_physics_constraint_strength_timelinePtr
          .asFunction<spine_physics_constraint_strength_timeline Function(spine_curve_timeline)>();

  spine_physics_constraint_timeline spine_curve_timeline_cast_to_physics_constraint_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_physics_constraint_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_physics_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_physics_constraint_timeline');
  late final _spine_curve_timeline_cast_to_physics_constraint_timeline =
      _spine_curve_timeline_cast_to_physics_constraint_timelinePtr
          .asFunction<spine_physics_constraint_timeline Function(spine_curve_timeline)>();

  spine_physics_constraint_wind_timeline spine_curve_timeline_cast_to_physics_constraint_wind_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_physics_constraint_wind_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_physics_constraint_wind_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_wind_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_physics_constraint_wind_timeline');
  late final _spine_curve_timeline_cast_to_physics_constraint_wind_timeline =
      _spine_curve_timeline_cast_to_physics_constraint_wind_timelinePtr
          .asFunction<spine_physics_constraint_wind_timeline Function(spine_curve_timeline)>();

  spine_rgb2_timeline spine_curve_timeline_cast_to_rgb2_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_rgb2_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_rgb2_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgb2_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_rgb2_timeline');
  late final _spine_curve_timeline_cast_to_rgb2_timeline =
      _spine_curve_timeline_cast_to_rgb2_timelinePtr.asFunction<spine_rgb2_timeline Function(spine_curve_timeline)>();

  spine_rgba2_timeline spine_curve_timeline_cast_to_rgba2_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_rgba2_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_rgba2_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgba2_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_rgba2_timeline');
  late final _spine_curve_timeline_cast_to_rgba2_timeline =
      _spine_curve_timeline_cast_to_rgba2_timelinePtr.asFunction<spine_rgba2_timeline Function(spine_curve_timeline)>();

  spine_rgba_timeline spine_curve_timeline_cast_to_rgba_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_rgba_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_rgba_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgba_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_rgba_timeline');
  late final _spine_curve_timeline_cast_to_rgba_timeline =
      _spine_curve_timeline_cast_to_rgba_timelinePtr.asFunction<spine_rgba_timeline Function(spine_curve_timeline)>();

  spine_rgb_timeline spine_curve_timeline_cast_to_rgb_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_rgb_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_rgb_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgb_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_rgb_timeline');
  late final _spine_curve_timeline_cast_to_rgb_timeline =
      _spine_curve_timeline_cast_to_rgb_timelinePtr.asFunction<spine_rgb_timeline Function(spine_curve_timeline)>();

  spine_rotate_timeline spine_curve_timeline_cast_to_rotate_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_rotate_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_rotate_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rotate_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_rotate_timeline');
  late final _spine_curve_timeline_cast_to_rotate_timeline = _spine_curve_timeline_cast_to_rotate_timelinePtr
      .asFunction<spine_rotate_timeline Function(spine_curve_timeline)>();

  spine_scale_timeline spine_curve_timeline_cast_to_scale_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_scale_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_scale_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_scale_timeline');
  late final _spine_curve_timeline_cast_to_scale_timeline =
      _spine_curve_timeline_cast_to_scale_timelinePtr.asFunction<spine_scale_timeline Function(spine_curve_timeline)>();

  spine_scale_x_timeline spine_curve_timeline_cast_to_scale_x_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_scale_x_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_scale_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_x_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_scale_x_timeline');
  late final _spine_curve_timeline_cast_to_scale_x_timeline = _spine_curve_timeline_cast_to_scale_x_timelinePtr
      .asFunction<spine_scale_x_timeline Function(spine_curve_timeline)>();

  spine_scale_y_timeline spine_curve_timeline_cast_to_scale_y_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_scale_y_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_scale_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_y_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_scale_y_timeline');
  late final _spine_curve_timeline_cast_to_scale_y_timeline = _spine_curve_timeline_cast_to_scale_y_timelinePtr
      .asFunction<spine_scale_y_timeline Function(spine_curve_timeline)>();

  spine_shear_timeline spine_curve_timeline_cast_to_shear_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_shear_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_shear_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_shear_timeline');
  late final _spine_curve_timeline_cast_to_shear_timeline =
      _spine_curve_timeline_cast_to_shear_timelinePtr.asFunction<spine_shear_timeline Function(spine_curve_timeline)>();

  spine_shear_x_timeline spine_curve_timeline_cast_to_shear_x_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_shear_x_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_shear_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_x_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_shear_x_timeline');
  late final _spine_curve_timeline_cast_to_shear_x_timeline = _spine_curve_timeline_cast_to_shear_x_timelinePtr
      .asFunction<spine_shear_x_timeline Function(spine_curve_timeline)>();

  spine_shear_y_timeline spine_curve_timeline_cast_to_shear_y_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_shear_y_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_shear_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_y_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_shear_y_timeline');
  late final _spine_curve_timeline_cast_to_shear_y_timeline = _spine_curve_timeline_cast_to_shear_y_timelinePtr
      .asFunction<spine_shear_y_timeline Function(spine_curve_timeline)>();

  spine_slider_mix_timeline spine_curve_timeline_cast_to_slider_mix_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_slider_mix_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_slider_mix_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slider_mix_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_slider_mix_timeline');
  late final _spine_curve_timeline_cast_to_slider_mix_timeline = _spine_curve_timeline_cast_to_slider_mix_timelinePtr
      .asFunction<spine_slider_mix_timeline Function(spine_curve_timeline)>();

  spine_slider_timeline spine_curve_timeline_cast_to_slider_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_slider_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_slider_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slider_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_slider_timeline');
  late final _spine_curve_timeline_cast_to_slider_timeline = _spine_curve_timeline_cast_to_slider_timelinePtr
      .asFunction<spine_slider_timeline Function(spine_curve_timeline)>();

  spine_slot_curve_timeline spine_curve_timeline_cast_to_slot_curve_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_slot_curve_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_slot_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_curve_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_slot_curve_timeline');
  late final _spine_curve_timeline_cast_to_slot_curve_timeline = _spine_curve_timeline_cast_to_slot_curve_timelinePtr
      .asFunction<spine_slot_curve_timeline Function(spine_curve_timeline)>();

  spine_transform_constraint_timeline spine_curve_timeline_cast_to_transform_constraint_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_transform_constraint_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_transform_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_transform_constraint_timeline');
  late final _spine_curve_timeline_cast_to_transform_constraint_timeline =
      _spine_curve_timeline_cast_to_transform_constraint_timelinePtr
          .asFunction<spine_transform_constraint_timeline Function(spine_curve_timeline)>();

  spine_translate_timeline spine_curve_timeline_cast_to_translate_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_translate_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_translate_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_translate_timeline');
  late final _spine_curve_timeline_cast_to_translate_timeline = _spine_curve_timeline_cast_to_translate_timelinePtr
      .asFunction<spine_translate_timeline Function(spine_curve_timeline)>();

  spine_translate_x_timeline spine_curve_timeline_cast_to_translate_x_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_translate_x_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_translate_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_x_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_translate_x_timeline');
  late final _spine_curve_timeline_cast_to_translate_x_timeline = _spine_curve_timeline_cast_to_translate_x_timelinePtr
      .asFunction<spine_translate_x_timeline Function(spine_curve_timeline)>();

  spine_translate_y_timeline spine_curve_timeline_cast_to_translate_y_timeline(
    spine_curve_timeline obj,
  ) {
    return _spine_curve_timeline_cast_to_translate_y_timeline(
      obj,
    );
  }

  late final _spine_curve_timeline_cast_to_translate_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_y_timeline Function(spine_curve_timeline)>>(
          'spine_curve_timeline_cast_to_translate_y_timeline');
  late final _spine_curve_timeline_cast_to_translate_y_timeline = _spine_curve_timeline_cast_to_translate_y_timelinePtr
      .asFunction<spine_translate_y_timeline Function(spine_curve_timeline)>();

  spine_alpha_timeline spine_timeline_cast_to_alpha_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_alpha_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_alpha_timelinePtr =
      _lookup<ffi.NativeFunction<spine_alpha_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_alpha_timeline');
  late final _spine_timeline_cast_to_alpha_timeline =
      _spine_timeline_cast_to_alpha_timelinePtr.asFunction<spine_alpha_timeline Function(spine_timeline)>();

  spine_attachment_timeline spine_timeline_cast_to_attachment_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_attachment_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_attachment_timelinePtr =
      _lookup<ffi.NativeFunction<spine_attachment_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_attachment_timeline');
  late final _spine_timeline_cast_to_attachment_timeline =
      _spine_timeline_cast_to_attachment_timelinePtr.asFunction<spine_attachment_timeline Function(spine_timeline)>();

  spine_bone_timeline1 spine_timeline_cast_to_bone_timeline1(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_bone_timeline1(
      obj,
    );
  }

  late final _spine_timeline_cast_to_bone_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline1 Function(spine_timeline)>>(
          'spine_timeline_cast_to_bone_timeline1');
  late final _spine_timeline_cast_to_bone_timeline1 =
      _spine_timeline_cast_to_bone_timeline1Ptr.asFunction<spine_bone_timeline1 Function(spine_timeline)>();

  spine_bone_timeline2 spine_timeline_cast_to_bone_timeline2(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_bone_timeline2(
      obj,
    );
  }

  late final _spine_timeline_cast_to_bone_timeline2Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline2 Function(spine_timeline)>>(
          'spine_timeline_cast_to_bone_timeline2');
  late final _spine_timeline_cast_to_bone_timeline2 =
      _spine_timeline_cast_to_bone_timeline2Ptr.asFunction<spine_bone_timeline2 Function(spine_timeline)>();

  spine_constraint_timeline1 spine_timeline_cast_to_constraint_timeline1(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_constraint_timeline1(
      obj,
    );
  }

  late final _spine_timeline_cast_to_constraint_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline1 Function(spine_timeline)>>(
          'spine_timeline_cast_to_constraint_timeline1');
  late final _spine_timeline_cast_to_constraint_timeline1 =
      _spine_timeline_cast_to_constraint_timeline1Ptr.asFunction<spine_constraint_timeline1 Function(spine_timeline)>();

  spine_curve_timeline spine_timeline_cast_to_curve_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_curve_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_curve_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_curve_timeline');
  late final _spine_timeline_cast_to_curve_timeline =
      _spine_timeline_cast_to_curve_timelinePtr.asFunction<spine_curve_timeline Function(spine_timeline)>();

  spine_curve_timeline1 spine_timeline_cast_to_curve_timeline1(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_curve_timeline1(
      obj,
    );
  }

  late final _spine_timeline_cast_to_curve_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_curve_timeline1 Function(spine_timeline)>>(
          'spine_timeline_cast_to_curve_timeline1');
  late final _spine_timeline_cast_to_curve_timeline1 =
      _spine_timeline_cast_to_curve_timeline1Ptr.asFunction<spine_curve_timeline1 Function(spine_timeline)>();

  spine_deform_timeline spine_timeline_cast_to_deform_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_deform_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_deform_timelinePtr =
      _lookup<ffi.NativeFunction<spine_deform_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_deform_timeline');
  late final _spine_timeline_cast_to_deform_timeline =
      _spine_timeline_cast_to_deform_timelinePtr.asFunction<spine_deform_timeline Function(spine_timeline)>();

  spine_draw_order_timeline spine_timeline_cast_to_draw_order_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_draw_order_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_draw_order_timelinePtr =
      _lookup<ffi.NativeFunction<spine_draw_order_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_draw_order_timeline');
  late final _spine_timeline_cast_to_draw_order_timeline =
      _spine_timeline_cast_to_draw_order_timelinePtr.asFunction<spine_draw_order_timeline Function(spine_timeline)>();

  spine_event_timeline spine_timeline_cast_to_event_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_event_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_event_timelinePtr =
      _lookup<ffi.NativeFunction<spine_event_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_event_timeline');
  late final _spine_timeline_cast_to_event_timeline =
      _spine_timeline_cast_to_event_timelinePtr.asFunction<spine_event_timeline Function(spine_timeline)>();

  spine_ik_constraint_timeline spine_timeline_cast_to_ik_constraint_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_ik_constraint_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_ik_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_ik_constraint_timeline');
  late final _spine_timeline_cast_to_ik_constraint_timeline = _spine_timeline_cast_to_ik_constraint_timelinePtr
      .asFunction<spine_ik_constraint_timeline Function(spine_timeline)>();

  spine_inherit_timeline spine_timeline_cast_to_inherit_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_inherit_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_inherit_timelinePtr =
      _lookup<ffi.NativeFunction<spine_inherit_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_inherit_timeline');
  late final _spine_timeline_cast_to_inherit_timeline =
      _spine_timeline_cast_to_inherit_timelinePtr.asFunction<spine_inherit_timeline Function(spine_timeline)>();

  spine_path_constraint_mix_timeline spine_timeline_cast_to_path_constraint_mix_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_path_constraint_mix_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_path_constraint_mix_timelinePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_mix_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_path_constraint_mix_timeline');
  late final _spine_timeline_cast_to_path_constraint_mix_timeline =
      _spine_timeline_cast_to_path_constraint_mix_timelinePtr
          .asFunction<spine_path_constraint_mix_timeline Function(spine_timeline)>();

  spine_path_constraint_position_timeline spine_timeline_cast_to_path_constraint_position_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_path_constraint_position_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_path_constraint_position_timelinePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_position_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_path_constraint_position_timeline');
  late final _spine_timeline_cast_to_path_constraint_position_timeline =
      _spine_timeline_cast_to_path_constraint_position_timelinePtr
          .asFunction<spine_path_constraint_position_timeline Function(spine_timeline)>();

  spine_path_constraint_spacing_timeline spine_timeline_cast_to_path_constraint_spacing_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_path_constraint_spacing_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_path_constraint_spacing_timelinePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_spacing_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_path_constraint_spacing_timeline');
  late final _spine_timeline_cast_to_path_constraint_spacing_timeline =
      _spine_timeline_cast_to_path_constraint_spacing_timelinePtr
          .asFunction<spine_path_constraint_spacing_timeline Function(spine_timeline)>();

  spine_physics_constraint_damping_timeline spine_timeline_cast_to_physics_constraint_damping_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_physics_constraint_damping_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_physics_constraint_damping_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_damping_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_physics_constraint_damping_timeline');
  late final _spine_timeline_cast_to_physics_constraint_damping_timeline =
      _spine_timeline_cast_to_physics_constraint_damping_timelinePtr
          .asFunction<spine_physics_constraint_damping_timeline Function(spine_timeline)>();

  spine_physics_constraint_gravity_timeline spine_timeline_cast_to_physics_constraint_gravity_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_physics_constraint_gravity_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_physics_constraint_gravity_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_gravity_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_physics_constraint_gravity_timeline');
  late final _spine_timeline_cast_to_physics_constraint_gravity_timeline =
      _spine_timeline_cast_to_physics_constraint_gravity_timelinePtr
          .asFunction<spine_physics_constraint_gravity_timeline Function(spine_timeline)>();

  spine_physics_constraint_inertia_timeline spine_timeline_cast_to_physics_constraint_inertia_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_physics_constraint_inertia_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_physics_constraint_inertia_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_inertia_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_physics_constraint_inertia_timeline');
  late final _spine_timeline_cast_to_physics_constraint_inertia_timeline =
      _spine_timeline_cast_to_physics_constraint_inertia_timelinePtr
          .asFunction<spine_physics_constraint_inertia_timeline Function(spine_timeline)>();

  spine_physics_constraint_mass_timeline spine_timeline_cast_to_physics_constraint_mass_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_physics_constraint_mass_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_physics_constraint_mass_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_mass_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_physics_constraint_mass_timeline');
  late final _spine_timeline_cast_to_physics_constraint_mass_timeline =
      _spine_timeline_cast_to_physics_constraint_mass_timelinePtr
          .asFunction<spine_physics_constraint_mass_timeline Function(spine_timeline)>();

  spine_physics_constraint_mix_timeline spine_timeline_cast_to_physics_constraint_mix_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_physics_constraint_mix_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_physics_constraint_mix_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_mix_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_physics_constraint_mix_timeline');
  late final _spine_timeline_cast_to_physics_constraint_mix_timeline =
      _spine_timeline_cast_to_physics_constraint_mix_timelinePtr
          .asFunction<spine_physics_constraint_mix_timeline Function(spine_timeline)>();

  spine_physics_constraint_reset_timeline spine_timeline_cast_to_physics_constraint_reset_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_physics_constraint_reset_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_physics_constraint_reset_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_reset_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_physics_constraint_reset_timeline');
  late final _spine_timeline_cast_to_physics_constraint_reset_timeline =
      _spine_timeline_cast_to_physics_constraint_reset_timelinePtr
          .asFunction<spine_physics_constraint_reset_timeline Function(spine_timeline)>();

  spine_physics_constraint_strength_timeline spine_timeline_cast_to_physics_constraint_strength_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_physics_constraint_strength_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_physics_constraint_strength_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_strength_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_physics_constraint_strength_timeline');
  late final _spine_timeline_cast_to_physics_constraint_strength_timeline =
      _spine_timeline_cast_to_physics_constraint_strength_timelinePtr
          .asFunction<spine_physics_constraint_strength_timeline Function(spine_timeline)>();

  spine_physics_constraint_timeline spine_timeline_cast_to_physics_constraint_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_physics_constraint_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_physics_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_physics_constraint_timeline');
  late final _spine_timeline_cast_to_physics_constraint_timeline =
      _spine_timeline_cast_to_physics_constraint_timelinePtr
          .asFunction<spine_physics_constraint_timeline Function(spine_timeline)>();

  spine_physics_constraint_wind_timeline spine_timeline_cast_to_physics_constraint_wind_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_physics_constraint_wind_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_physics_constraint_wind_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_wind_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_physics_constraint_wind_timeline');
  late final _spine_timeline_cast_to_physics_constraint_wind_timeline =
      _spine_timeline_cast_to_physics_constraint_wind_timelinePtr
          .asFunction<spine_physics_constraint_wind_timeline Function(spine_timeline)>();

  spine_rgb2_timeline spine_timeline_cast_to_rgb2_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_rgb2_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_rgb2_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgb2_timeline Function(spine_timeline)>>('spine_timeline_cast_to_rgb2_timeline');
  late final _spine_timeline_cast_to_rgb2_timeline =
      _spine_timeline_cast_to_rgb2_timelinePtr.asFunction<spine_rgb2_timeline Function(spine_timeline)>();

  spine_rgba2_timeline spine_timeline_cast_to_rgba2_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_rgba2_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_rgba2_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgba2_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_rgba2_timeline');
  late final _spine_timeline_cast_to_rgba2_timeline =
      _spine_timeline_cast_to_rgba2_timelinePtr.asFunction<spine_rgba2_timeline Function(spine_timeline)>();

  spine_rgba_timeline spine_timeline_cast_to_rgba_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_rgba_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_rgba_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgba_timeline Function(spine_timeline)>>('spine_timeline_cast_to_rgba_timeline');
  late final _spine_timeline_cast_to_rgba_timeline =
      _spine_timeline_cast_to_rgba_timelinePtr.asFunction<spine_rgba_timeline Function(spine_timeline)>();

  spine_rgb_timeline spine_timeline_cast_to_rgb_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_rgb_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_rgb_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgb_timeline Function(spine_timeline)>>('spine_timeline_cast_to_rgb_timeline');
  late final _spine_timeline_cast_to_rgb_timeline =
      _spine_timeline_cast_to_rgb_timelinePtr.asFunction<spine_rgb_timeline Function(spine_timeline)>();

  spine_rotate_timeline spine_timeline_cast_to_rotate_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_rotate_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_rotate_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rotate_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_rotate_timeline');
  late final _spine_timeline_cast_to_rotate_timeline =
      _spine_timeline_cast_to_rotate_timelinePtr.asFunction<spine_rotate_timeline Function(spine_timeline)>();

  spine_scale_timeline spine_timeline_cast_to_scale_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_scale_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_scale_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_scale_timeline');
  late final _spine_timeline_cast_to_scale_timeline =
      _spine_timeline_cast_to_scale_timelinePtr.asFunction<spine_scale_timeline Function(spine_timeline)>();

  spine_scale_x_timeline spine_timeline_cast_to_scale_x_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_scale_x_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_scale_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_x_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_scale_x_timeline');
  late final _spine_timeline_cast_to_scale_x_timeline =
      _spine_timeline_cast_to_scale_x_timelinePtr.asFunction<spine_scale_x_timeline Function(spine_timeline)>();

  spine_scale_y_timeline spine_timeline_cast_to_scale_y_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_scale_y_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_scale_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_y_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_scale_y_timeline');
  late final _spine_timeline_cast_to_scale_y_timeline =
      _spine_timeline_cast_to_scale_y_timelinePtr.asFunction<spine_scale_y_timeline Function(spine_timeline)>();

  spine_sequence_timeline spine_timeline_cast_to_sequence_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_sequence_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_sequence_timelinePtr =
      _lookup<ffi.NativeFunction<spine_sequence_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_sequence_timeline');
  late final _spine_timeline_cast_to_sequence_timeline =
      _spine_timeline_cast_to_sequence_timelinePtr.asFunction<spine_sequence_timeline Function(spine_timeline)>();

  spine_shear_timeline spine_timeline_cast_to_shear_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_shear_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_shear_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_shear_timeline');
  late final _spine_timeline_cast_to_shear_timeline =
      _spine_timeline_cast_to_shear_timelinePtr.asFunction<spine_shear_timeline Function(spine_timeline)>();

  spine_shear_x_timeline spine_timeline_cast_to_shear_x_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_shear_x_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_shear_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_x_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_shear_x_timeline');
  late final _spine_timeline_cast_to_shear_x_timeline =
      _spine_timeline_cast_to_shear_x_timelinePtr.asFunction<spine_shear_x_timeline Function(spine_timeline)>();

  spine_shear_y_timeline spine_timeline_cast_to_shear_y_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_shear_y_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_shear_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_y_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_shear_y_timeline');
  late final _spine_timeline_cast_to_shear_y_timeline =
      _spine_timeline_cast_to_shear_y_timelinePtr.asFunction<spine_shear_y_timeline Function(spine_timeline)>();

  spine_slider_mix_timeline spine_timeline_cast_to_slider_mix_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_slider_mix_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_slider_mix_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slider_mix_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_slider_mix_timeline');
  late final _spine_timeline_cast_to_slider_mix_timeline =
      _spine_timeline_cast_to_slider_mix_timelinePtr.asFunction<spine_slider_mix_timeline Function(spine_timeline)>();

  spine_slider_timeline spine_timeline_cast_to_slider_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_slider_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_slider_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slider_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_slider_timeline');
  late final _spine_timeline_cast_to_slider_timeline =
      _spine_timeline_cast_to_slider_timelinePtr.asFunction<spine_slider_timeline Function(spine_timeline)>();

  spine_slot_curve_timeline spine_timeline_cast_to_slot_curve_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_slot_curve_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_slot_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_curve_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_slot_curve_timeline');
  late final _spine_timeline_cast_to_slot_curve_timeline =
      _spine_timeline_cast_to_slot_curve_timelinePtr.asFunction<spine_slot_curve_timeline Function(spine_timeline)>();

  spine_transform_constraint_timeline spine_timeline_cast_to_transform_constraint_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_transform_constraint_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_transform_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_transform_constraint_timeline');
  late final _spine_timeline_cast_to_transform_constraint_timeline =
      _spine_timeline_cast_to_transform_constraint_timelinePtr
          .asFunction<spine_transform_constraint_timeline Function(spine_timeline)>();

  spine_translate_timeline spine_timeline_cast_to_translate_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_translate_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_translate_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_translate_timeline');
  late final _spine_timeline_cast_to_translate_timeline =
      _spine_timeline_cast_to_translate_timelinePtr.asFunction<spine_translate_timeline Function(spine_timeline)>();

  spine_translate_x_timeline spine_timeline_cast_to_translate_x_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_translate_x_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_translate_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_x_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_translate_x_timeline');
  late final _spine_timeline_cast_to_translate_x_timeline =
      _spine_timeline_cast_to_translate_x_timelinePtr.asFunction<spine_translate_x_timeline Function(spine_timeline)>();

  spine_translate_y_timeline spine_timeline_cast_to_translate_y_timeline(
    spine_timeline obj,
  ) {
    return _spine_timeline_cast_to_translate_y_timeline(
      obj,
    );
  }

  late final _spine_timeline_cast_to_translate_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_y_timeline Function(spine_timeline)>>(
          'spine_timeline_cast_to_translate_y_timeline');
  late final _spine_timeline_cast_to_translate_y_timeline =
      _spine_timeline_cast_to_translate_y_timelinePtr.asFunction<spine_translate_y_timeline Function(spine_timeline)>();

  spine_alpha_timeline spine_slot_timeline_cast_to_alpha_timeline(
    spine_slot_timeline obj,
  ) {
    return _spine_slot_timeline_cast_to_alpha_timeline(
      obj,
    );
  }

  late final _spine_slot_timeline_cast_to_alpha_timelinePtr =
      _lookup<ffi.NativeFunction<spine_alpha_timeline Function(spine_slot_timeline)>>(
          'spine_slot_timeline_cast_to_alpha_timeline');
  late final _spine_slot_timeline_cast_to_alpha_timeline =
      _spine_slot_timeline_cast_to_alpha_timelinePtr.asFunction<spine_alpha_timeline Function(spine_slot_timeline)>();

  spine_attachment_timeline spine_slot_timeline_cast_to_attachment_timeline(
    spine_slot_timeline obj,
  ) {
    return _spine_slot_timeline_cast_to_attachment_timeline(
      obj,
    );
  }

  late final _spine_slot_timeline_cast_to_attachment_timelinePtr =
      _lookup<ffi.NativeFunction<spine_attachment_timeline Function(spine_slot_timeline)>>(
          'spine_slot_timeline_cast_to_attachment_timeline');
  late final _spine_slot_timeline_cast_to_attachment_timeline = _spine_slot_timeline_cast_to_attachment_timelinePtr
      .asFunction<spine_attachment_timeline Function(spine_slot_timeline)>();

  spine_deform_timeline spine_slot_timeline_cast_to_deform_timeline(
    spine_slot_timeline obj,
  ) {
    return _spine_slot_timeline_cast_to_deform_timeline(
      obj,
    );
  }

  late final _spine_slot_timeline_cast_to_deform_timelinePtr =
      _lookup<ffi.NativeFunction<spine_deform_timeline Function(spine_slot_timeline)>>(
          'spine_slot_timeline_cast_to_deform_timeline');
  late final _spine_slot_timeline_cast_to_deform_timeline =
      _spine_slot_timeline_cast_to_deform_timelinePtr.asFunction<spine_deform_timeline Function(spine_slot_timeline)>();

  spine_rgb2_timeline spine_slot_timeline_cast_to_rgb2_timeline(
    spine_slot_timeline obj,
  ) {
    return _spine_slot_timeline_cast_to_rgb2_timeline(
      obj,
    );
  }

  late final _spine_slot_timeline_cast_to_rgb2_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgb2_timeline Function(spine_slot_timeline)>>(
          'spine_slot_timeline_cast_to_rgb2_timeline');
  late final _spine_slot_timeline_cast_to_rgb2_timeline =
      _spine_slot_timeline_cast_to_rgb2_timelinePtr.asFunction<spine_rgb2_timeline Function(spine_slot_timeline)>();

  spine_rgba2_timeline spine_slot_timeline_cast_to_rgba2_timeline(
    spine_slot_timeline obj,
  ) {
    return _spine_slot_timeline_cast_to_rgba2_timeline(
      obj,
    );
  }

  late final _spine_slot_timeline_cast_to_rgba2_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgba2_timeline Function(spine_slot_timeline)>>(
          'spine_slot_timeline_cast_to_rgba2_timeline');
  late final _spine_slot_timeline_cast_to_rgba2_timeline =
      _spine_slot_timeline_cast_to_rgba2_timelinePtr.asFunction<spine_rgba2_timeline Function(spine_slot_timeline)>();

  spine_rgba_timeline spine_slot_timeline_cast_to_rgba_timeline(
    spine_slot_timeline obj,
  ) {
    return _spine_slot_timeline_cast_to_rgba_timeline(
      obj,
    );
  }

  late final _spine_slot_timeline_cast_to_rgba_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgba_timeline Function(spine_slot_timeline)>>(
          'spine_slot_timeline_cast_to_rgba_timeline');
  late final _spine_slot_timeline_cast_to_rgba_timeline =
      _spine_slot_timeline_cast_to_rgba_timelinePtr.asFunction<spine_rgba_timeline Function(spine_slot_timeline)>();

  spine_rgb_timeline spine_slot_timeline_cast_to_rgb_timeline(
    spine_slot_timeline obj,
  ) {
    return _spine_slot_timeline_cast_to_rgb_timeline(
      obj,
    );
  }

  late final _spine_slot_timeline_cast_to_rgb_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgb_timeline Function(spine_slot_timeline)>>(
          'spine_slot_timeline_cast_to_rgb_timeline');
  late final _spine_slot_timeline_cast_to_rgb_timeline =
      _spine_slot_timeline_cast_to_rgb_timelinePtr.asFunction<spine_rgb_timeline Function(spine_slot_timeline)>();

  spine_sequence_timeline spine_slot_timeline_cast_to_sequence_timeline(
    spine_slot_timeline obj,
  ) {
    return _spine_slot_timeline_cast_to_sequence_timeline(
      obj,
    );
  }

  late final _spine_slot_timeline_cast_to_sequence_timelinePtr =
      _lookup<ffi.NativeFunction<spine_sequence_timeline Function(spine_slot_timeline)>>(
          'spine_slot_timeline_cast_to_sequence_timeline');
  late final _spine_slot_timeline_cast_to_sequence_timeline = _spine_slot_timeline_cast_to_sequence_timelinePtr
      .asFunction<spine_sequence_timeline Function(spine_slot_timeline)>();

  spine_slot_curve_timeline spine_slot_timeline_cast_to_slot_curve_timeline(
    spine_slot_timeline obj,
  ) {
    return _spine_slot_timeline_cast_to_slot_curve_timeline(
      obj,
    );
  }

  late final _spine_slot_timeline_cast_to_slot_curve_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slot_curve_timeline Function(spine_slot_timeline)>>(
          'spine_slot_timeline_cast_to_slot_curve_timeline');
  late final _spine_slot_timeline_cast_to_slot_curve_timeline = _spine_slot_timeline_cast_to_slot_curve_timelinePtr
      .asFunction<spine_slot_curve_timeline Function(spine_slot_timeline)>();

  spine_atlas_attachment_loader spine_attachment_loader_cast_to_atlas_attachment_loader(
    spine_attachment_loader obj,
  ) {
    return _spine_attachment_loader_cast_to_atlas_attachment_loader(
      obj,
    );
  }

  late final _spine_attachment_loader_cast_to_atlas_attachment_loaderPtr =
      _lookup<ffi.NativeFunction<spine_atlas_attachment_loader Function(spine_attachment_loader)>>(
          'spine_attachment_loader_cast_to_atlas_attachment_loader');
  late final _spine_attachment_loader_cast_to_atlas_attachment_loader =
      _spine_attachment_loader_cast_to_atlas_attachment_loaderPtr
          .asFunction<spine_atlas_attachment_loader Function(spine_attachment_loader)>();

  spine_atlas_region spine_texture_region_cast_to_atlas_region(
    spine_texture_region obj,
  ) {
    return _spine_texture_region_cast_to_atlas_region(
      obj,
    );
  }

  late final _spine_texture_region_cast_to_atlas_regionPtr =
      _lookup<ffi.NativeFunction<spine_atlas_region Function(spine_texture_region)>>(
          'spine_texture_region_cast_to_atlas_region');
  late final _spine_texture_region_cast_to_atlas_region =
      _spine_texture_region_cast_to_atlas_regionPtr.asFunction<spine_atlas_region Function(spine_texture_region)>();

  spine_bone spine_posed_cast_to_bone(
    spine_posed obj,
  ) {
    return _spine_posed_cast_to_bone(
      obj,
    );
  }

  late final _spine_posed_cast_to_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_posed)>>('spine_posed_cast_to_bone');
  late final _spine_posed_cast_to_bone = _spine_posed_cast_to_bonePtr.asFunction<spine_bone Function(spine_posed)>();

  spine_ik_constraint spine_posed_cast_to_ik_constraint(
    spine_posed obj,
  ) {
    return _spine_posed_cast_to_ik_constraint(
      obj,
    );
  }

  late final _spine_posed_cast_to_ik_constraintPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint Function(spine_posed)>>('spine_posed_cast_to_ik_constraint');
  late final _spine_posed_cast_to_ik_constraint =
      _spine_posed_cast_to_ik_constraintPtr.asFunction<spine_ik_constraint Function(spine_posed)>();

  spine_ik_constraint_base spine_posed_cast_to_ik_constraint_base(
    spine_posed obj,
  ) {
    return _spine_posed_cast_to_ik_constraint_base(
      obj,
    );
  }

  late final _spine_posed_cast_to_ik_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_base Function(spine_posed)>>(
          'spine_posed_cast_to_ik_constraint_base');
  late final _spine_posed_cast_to_ik_constraint_base =
      _spine_posed_cast_to_ik_constraint_basePtr.asFunction<spine_ik_constraint_base Function(spine_posed)>();

  spine_path_constraint spine_posed_cast_to_path_constraint(
    spine_posed obj,
  ) {
    return _spine_posed_cast_to_path_constraint(
      obj,
    );
  }

  late final _spine_posed_cast_to_path_constraintPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint Function(spine_posed)>>('spine_posed_cast_to_path_constraint');
  late final _spine_posed_cast_to_path_constraint =
      _spine_posed_cast_to_path_constraintPtr.asFunction<spine_path_constraint Function(spine_posed)>();

  spine_path_constraint_base spine_posed_cast_to_path_constraint_base(
    spine_posed obj,
  ) {
    return _spine_posed_cast_to_path_constraint_base(
      obj,
    );
  }

  late final _spine_posed_cast_to_path_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_base Function(spine_posed)>>(
          'spine_posed_cast_to_path_constraint_base');
  late final _spine_posed_cast_to_path_constraint_base =
      _spine_posed_cast_to_path_constraint_basePtr.asFunction<spine_path_constraint_base Function(spine_posed)>();

  spine_physics_constraint spine_posed_cast_to_physics_constraint(
    spine_posed obj,
  ) {
    return _spine_posed_cast_to_physics_constraint(
      obj,
    );
  }

  late final _spine_posed_cast_to_physics_constraintPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint Function(spine_posed)>>(
          'spine_posed_cast_to_physics_constraint');
  late final _spine_posed_cast_to_physics_constraint =
      _spine_posed_cast_to_physics_constraintPtr.asFunction<spine_physics_constraint Function(spine_posed)>();

  spine_physics_constraint_base spine_posed_cast_to_physics_constraint_base(
    spine_posed obj,
  ) {
    return _spine_posed_cast_to_physics_constraint_base(
      obj,
    );
  }

  late final _spine_posed_cast_to_physics_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_base Function(spine_posed)>>(
          'spine_posed_cast_to_physics_constraint_base');
  late final _spine_posed_cast_to_physics_constraint_base =
      _spine_posed_cast_to_physics_constraint_basePtr.asFunction<spine_physics_constraint_base Function(spine_posed)>();

  spine_slider spine_posed_cast_to_slider(
    spine_posed obj,
  ) {
    return _spine_posed_cast_to_slider(
      obj,
    );
  }

  late final _spine_posed_cast_to_sliderPtr =
      _lookup<ffi.NativeFunction<spine_slider Function(spine_posed)>>('spine_posed_cast_to_slider');
  late final _spine_posed_cast_to_slider =
      _spine_posed_cast_to_sliderPtr.asFunction<spine_slider Function(spine_posed)>();

  spine_slider_base spine_posed_cast_to_slider_base(
    spine_posed obj,
  ) {
    return _spine_posed_cast_to_slider_base(
      obj,
    );
  }

  late final _spine_posed_cast_to_slider_basePtr =
      _lookup<ffi.NativeFunction<spine_slider_base Function(spine_posed)>>('spine_posed_cast_to_slider_base');
  late final _spine_posed_cast_to_slider_base =
      _spine_posed_cast_to_slider_basePtr.asFunction<spine_slider_base Function(spine_posed)>();

  spine_slot spine_posed_cast_to_slot(
    spine_posed obj,
  ) {
    return _spine_posed_cast_to_slot(
      obj,
    );
  }

  late final _spine_posed_cast_to_slotPtr =
      _lookup<ffi.NativeFunction<spine_slot Function(spine_posed)>>('spine_posed_cast_to_slot');
  late final _spine_posed_cast_to_slot = _spine_posed_cast_to_slotPtr.asFunction<spine_slot Function(spine_posed)>();

  spine_transform_constraint spine_posed_cast_to_transform_constraint(
    spine_posed obj,
  ) {
    return _spine_posed_cast_to_transform_constraint(
      obj,
    );
  }

  late final _spine_posed_cast_to_transform_constraintPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint Function(spine_posed)>>(
          'spine_posed_cast_to_transform_constraint');
  late final _spine_posed_cast_to_transform_constraint =
      _spine_posed_cast_to_transform_constraintPtr.asFunction<spine_transform_constraint Function(spine_posed)>();

  spine_transform_constraint_base spine_posed_cast_to_transform_constraint_base(
    spine_posed obj,
  ) {
    return _spine_posed_cast_to_transform_constraint_base(
      obj,
    );
  }

  late final _spine_posed_cast_to_transform_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_base Function(spine_posed)>>(
          'spine_posed_cast_to_transform_constraint_base');
  late final _spine_posed_cast_to_transform_constraint_base = _spine_posed_cast_to_transform_constraint_basePtr
      .asFunction<spine_transform_constraint_base Function(spine_posed)>();

  spine_bone spine_posed_active_cast_to_bone(
    spine_posed_active obj,
  ) {
    return _spine_posed_active_cast_to_bone(
      obj,
    );
  }

  late final _spine_posed_active_cast_to_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_posed_active)>>('spine_posed_active_cast_to_bone');
  late final _spine_posed_active_cast_to_bone =
      _spine_posed_active_cast_to_bonePtr.asFunction<spine_bone Function(spine_posed_active)>();

  spine_ik_constraint spine_posed_active_cast_to_ik_constraint(
    spine_posed_active obj,
  ) {
    return _spine_posed_active_cast_to_ik_constraint(
      obj,
    );
  }

  late final _spine_posed_active_cast_to_ik_constraintPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint Function(spine_posed_active)>>(
          'spine_posed_active_cast_to_ik_constraint');
  late final _spine_posed_active_cast_to_ik_constraint =
      _spine_posed_active_cast_to_ik_constraintPtr.asFunction<spine_ik_constraint Function(spine_posed_active)>();

  spine_ik_constraint_base spine_posed_active_cast_to_ik_constraint_base(
    spine_posed_active obj,
  ) {
    return _spine_posed_active_cast_to_ik_constraint_base(
      obj,
    );
  }

  late final _spine_posed_active_cast_to_ik_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_base Function(spine_posed_active)>>(
          'spine_posed_active_cast_to_ik_constraint_base');
  late final _spine_posed_active_cast_to_ik_constraint_base = _spine_posed_active_cast_to_ik_constraint_basePtr
      .asFunction<spine_ik_constraint_base Function(spine_posed_active)>();

  spine_path_constraint spine_posed_active_cast_to_path_constraint(
    spine_posed_active obj,
  ) {
    return _spine_posed_active_cast_to_path_constraint(
      obj,
    );
  }

  late final _spine_posed_active_cast_to_path_constraintPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint Function(spine_posed_active)>>(
          'spine_posed_active_cast_to_path_constraint');
  late final _spine_posed_active_cast_to_path_constraint =
      _spine_posed_active_cast_to_path_constraintPtr.asFunction<spine_path_constraint Function(spine_posed_active)>();

  spine_path_constraint_base spine_posed_active_cast_to_path_constraint_base(
    spine_posed_active obj,
  ) {
    return _spine_posed_active_cast_to_path_constraint_base(
      obj,
    );
  }

  late final _spine_posed_active_cast_to_path_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_base Function(spine_posed_active)>>(
          'spine_posed_active_cast_to_path_constraint_base');
  late final _spine_posed_active_cast_to_path_constraint_base = _spine_posed_active_cast_to_path_constraint_basePtr
      .asFunction<spine_path_constraint_base Function(spine_posed_active)>();

  spine_physics_constraint spine_posed_active_cast_to_physics_constraint(
    spine_posed_active obj,
  ) {
    return _spine_posed_active_cast_to_physics_constraint(
      obj,
    );
  }

  late final _spine_posed_active_cast_to_physics_constraintPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint Function(spine_posed_active)>>(
          'spine_posed_active_cast_to_physics_constraint');
  late final _spine_posed_active_cast_to_physics_constraint = _spine_posed_active_cast_to_physics_constraintPtr
      .asFunction<spine_physics_constraint Function(spine_posed_active)>();

  spine_physics_constraint_base spine_posed_active_cast_to_physics_constraint_base(
    spine_posed_active obj,
  ) {
    return _spine_posed_active_cast_to_physics_constraint_base(
      obj,
    );
  }

  late final _spine_posed_active_cast_to_physics_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_base Function(spine_posed_active)>>(
          'spine_posed_active_cast_to_physics_constraint_base');
  late final _spine_posed_active_cast_to_physics_constraint_base =
      _spine_posed_active_cast_to_physics_constraint_basePtr
          .asFunction<spine_physics_constraint_base Function(spine_posed_active)>();

  spine_slider spine_posed_active_cast_to_slider(
    spine_posed_active obj,
  ) {
    return _spine_posed_active_cast_to_slider(
      obj,
    );
  }

  late final _spine_posed_active_cast_to_sliderPtr =
      _lookup<ffi.NativeFunction<spine_slider Function(spine_posed_active)>>('spine_posed_active_cast_to_slider');
  late final _spine_posed_active_cast_to_slider =
      _spine_posed_active_cast_to_sliderPtr.asFunction<spine_slider Function(spine_posed_active)>();

  spine_slider_base spine_posed_active_cast_to_slider_base(
    spine_posed_active obj,
  ) {
    return _spine_posed_active_cast_to_slider_base(
      obj,
    );
  }

  late final _spine_posed_active_cast_to_slider_basePtr =
      _lookup<ffi.NativeFunction<spine_slider_base Function(spine_posed_active)>>(
          'spine_posed_active_cast_to_slider_base');
  late final _spine_posed_active_cast_to_slider_base =
      _spine_posed_active_cast_to_slider_basePtr.asFunction<spine_slider_base Function(spine_posed_active)>();

  spine_transform_constraint spine_posed_active_cast_to_transform_constraint(
    spine_posed_active obj,
  ) {
    return _spine_posed_active_cast_to_transform_constraint(
      obj,
    );
  }

  late final _spine_posed_active_cast_to_transform_constraintPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint Function(spine_posed_active)>>(
          'spine_posed_active_cast_to_transform_constraint');
  late final _spine_posed_active_cast_to_transform_constraint = _spine_posed_active_cast_to_transform_constraintPtr
      .asFunction<spine_transform_constraint Function(spine_posed_active)>();

  spine_transform_constraint_base spine_posed_active_cast_to_transform_constraint_base(
    spine_posed_active obj,
  ) {
    return _spine_posed_active_cast_to_transform_constraint_base(
      obj,
    );
  }

  late final _spine_posed_active_cast_to_transform_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_base Function(spine_posed_active)>>(
          'spine_posed_active_cast_to_transform_constraint_base');
  late final _spine_posed_active_cast_to_transform_constraint_base =
      _spine_posed_active_cast_to_transform_constraint_basePtr
          .asFunction<spine_transform_constraint_base Function(spine_posed_active)>();

  spine_bone spine_update_cast_to_bone(
    spine_update obj,
  ) {
    return _spine_update_cast_to_bone(
      obj,
    );
  }

  late final _spine_update_cast_to_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_update)>>('spine_update_cast_to_bone');
  late final _spine_update_cast_to_bone = _spine_update_cast_to_bonePtr.asFunction<spine_bone Function(spine_update)>();

  spine_bone_pose spine_update_cast_to_bone_pose(
    spine_update obj,
  ) {
    return _spine_update_cast_to_bone_pose(
      obj,
    );
  }

  late final _spine_update_cast_to_bone_posePtr =
      _lookup<ffi.NativeFunction<spine_bone_pose Function(spine_update)>>('spine_update_cast_to_bone_pose');
  late final _spine_update_cast_to_bone_pose =
      _spine_update_cast_to_bone_posePtr.asFunction<spine_bone_pose Function(spine_update)>();

  spine_constraint spine_update_cast_to_constraint(
    spine_update obj,
  ) {
    return _spine_update_cast_to_constraint(
      obj,
    );
  }

  late final _spine_update_cast_to_constraintPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_update)>>('spine_update_cast_to_constraint');
  late final _spine_update_cast_to_constraint =
      _spine_update_cast_to_constraintPtr.asFunction<spine_constraint Function(spine_update)>();

  spine_ik_constraint spine_update_cast_to_ik_constraint(
    spine_update obj,
  ) {
    return _spine_update_cast_to_ik_constraint(
      obj,
    );
  }

  late final _spine_update_cast_to_ik_constraintPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint Function(spine_update)>>('spine_update_cast_to_ik_constraint');
  late final _spine_update_cast_to_ik_constraint =
      _spine_update_cast_to_ik_constraintPtr.asFunction<spine_ik_constraint Function(spine_update)>();

  spine_ik_constraint_base spine_update_cast_to_ik_constraint_base(
    spine_update obj,
  ) {
    return _spine_update_cast_to_ik_constraint_base(
      obj,
    );
  }

  late final _spine_update_cast_to_ik_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_base Function(spine_update)>>(
          'spine_update_cast_to_ik_constraint_base');
  late final _spine_update_cast_to_ik_constraint_base =
      _spine_update_cast_to_ik_constraint_basePtr.asFunction<spine_ik_constraint_base Function(spine_update)>();

  spine_path_constraint spine_update_cast_to_path_constraint(
    spine_update obj,
  ) {
    return _spine_update_cast_to_path_constraint(
      obj,
    );
  }

  late final _spine_update_cast_to_path_constraintPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint Function(spine_update)>>('spine_update_cast_to_path_constraint');
  late final _spine_update_cast_to_path_constraint =
      _spine_update_cast_to_path_constraintPtr.asFunction<spine_path_constraint Function(spine_update)>();

  spine_path_constraint_base spine_update_cast_to_path_constraint_base(
    spine_update obj,
  ) {
    return _spine_update_cast_to_path_constraint_base(
      obj,
    );
  }

  late final _spine_update_cast_to_path_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_base Function(spine_update)>>(
          'spine_update_cast_to_path_constraint_base');
  late final _spine_update_cast_to_path_constraint_base =
      _spine_update_cast_to_path_constraint_basePtr.asFunction<spine_path_constraint_base Function(spine_update)>();

  spine_physics_constraint spine_update_cast_to_physics_constraint(
    spine_update obj,
  ) {
    return _spine_update_cast_to_physics_constraint(
      obj,
    );
  }

  late final _spine_update_cast_to_physics_constraintPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint Function(spine_update)>>(
          'spine_update_cast_to_physics_constraint');
  late final _spine_update_cast_to_physics_constraint =
      _spine_update_cast_to_physics_constraintPtr.asFunction<spine_physics_constraint Function(spine_update)>();

  spine_physics_constraint_base spine_update_cast_to_physics_constraint_base(
    spine_update obj,
  ) {
    return _spine_update_cast_to_physics_constraint_base(
      obj,
    );
  }

  late final _spine_update_cast_to_physics_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_base Function(spine_update)>>(
          'spine_update_cast_to_physics_constraint_base');
  late final _spine_update_cast_to_physics_constraint_base = _spine_update_cast_to_physics_constraint_basePtr
      .asFunction<spine_physics_constraint_base Function(spine_update)>();

  spine_slider spine_update_cast_to_slider(
    spine_update obj,
  ) {
    return _spine_update_cast_to_slider(
      obj,
    );
  }

  late final _spine_update_cast_to_sliderPtr =
      _lookup<ffi.NativeFunction<spine_slider Function(spine_update)>>('spine_update_cast_to_slider');
  late final _spine_update_cast_to_slider =
      _spine_update_cast_to_sliderPtr.asFunction<spine_slider Function(spine_update)>();

  spine_slider_base spine_update_cast_to_slider_base(
    spine_update obj,
  ) {
    return _spine_update_cast_to_slider_base(
      obj,
    );
  }

  late final _spine_update_cast_to_slider_basePtr =
      _lookup<ffi.NativeFunction<spine_slider_base Function(spine_update)>>('spine_update_cast_to_slider_base');
  late final _spine_update_cast_to_slider_base =
      _spine_update_cast_to_slider_basePtr.asFunction<spine_slider_base Function(spine_update)>();

  spine_transform_constraint spine_update_cast_to_transform_constraint(
    spine_update obj,
  ) {
    return _spine_update_cast_to_transform_constraint(
      obj,
    );
  }

  late final _spine_update_cast_to_transform_constraintPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint Function(spine_update)>>(
          'spine_update_cast_to_transform_constraint');
  late final _spine_update_cast_to_transform_constraint =
      _spine_update_cast_to_transform_constraintPtr.asFunction<spine_transform_constraint Function(spine_update)>();

  spine_transform_constraint_base spine_update_cast_to_transform_constraint_base(
    spine_update obj,
  ) {
    return _spine_update_cast_to_transform_constraint_base(
      obj,
    );
  }

  late final _spine_update_cast_to_transform_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_base Function(spine_update)>>(
          'spine_update_cast_to_transform_constraint_base');
  late final _spine_update_cast_to_transform_constraint_base = _spine_update_cast_to_transform_constraint_basePtr
      .asFunction<spine_transform_constraint_base Function(spine_update)>();

  spine_bone_data spine_posed_data_cast_to_bone_data(
    spine_posed_data obj,
  ) {
    return _spine_posed_data_cast_to_bone_data(
      obj,
    );
  }

  late final _spine_posed_data_cast_to_bone_dataPtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_posed_data)>>('spine_posed_data_cast_to_bone_data');
  late final _spine_posed_data_cast_to_bone_data =
      _spine_posed_data_cast_to_bone_dataPtr.asFunction<spine_bone_data Function(spine_posed_data)>();

  spine_ik_constraint_data spine_posed_data_cast_to_ik_constraint_data(
    spine_posed_data obj,
  ) {
    return _spine_posed_data_cast_to_ik_constraint_data(
      obj,
    );
  }

  late final _spine_posed_data_cast_to_ik_constraint_dataPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_data Function(spine_posed_data)>>(
          'spine_posed_data_cast_to_ik_constraint_data');
  late final _spine_posed_data_cast_to_ik_constraint_data =
      _spine_posed_data_cast_to_ik_constraint_dataPtr.asFunction<spine_ik_constraint_data Function(spine_posed_data)>();

  spine_path_constraint_data spine_posed_data_cast_to_path_constraint_data(
    spine_posed_data obj,
  ) {
    return _spine_posed_data_cast_to_path_constraint_data(
      obj,
    );
  }

  late final _spine_posed_data_cast_to_path_constraint_dataPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_data Function(spine_posed_data)>>(
          'spine_posed_data_cast_to_path_constraint_data');
  late final _spine_posed_data_cast_to_path_constraint_data = _spine_posed_data_cast_to_path_constraint_dataPtr
      .asFunction<spine_path_constraint_data Function(spine_posed_data)>();

  spine_physics_constraint_data spine_posed_data_cast_to_physics_constraint_data(
    spine_posed_data obj,
  ) {
    return _spine_posed_data_cast_to_physics_constraint_data(
      obj,
    );
  }

  late final _spine_posed_data_cast_to_physics_constraint_dataPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_data Function(spine_posed_data)>>(
          'spine_posed_data_cast_to_physics_constraint_data');
  late final _spine_posed_data_cast_to_physics_constraint_data = _spine_posed_data_cast_to_physics_constraint_dataPtr
      .asFunction<spine_physics_constraint_data Function(spine_posed_data)>();

  spine_slider_data spine_posed_data_cast_to_slider_data(
    spine_posed_data obj,
  ) {
    return _spine_posed_data_cast_to_slider_data(
      obj,
    );
  }

  late final _spine_posed_data_cast_to_slider_dataPtr =
      _lookup<ffi.NativeFunction<spine_slider_data Function(spine_posed_data)>>('spine_posed_data_cast_to_slider_data');
  late final _spine_posed_data_cast_to_slider_data =
      _spine_posed_data_cast_to_slider_dataPtr.asFunction<spine_slider_data Function(spine_posed_data)>();

  spine_slot_data spine_posed_data_cast_to_slot_data(
    spine_posed_data obj,
  ) {
    return _spine_posed_data_cast_to_slot_data(
      obj,
    );
  }

  late final _spine_posed_data_cast_to_slot_dataPtr =
      _lookup<ffi.NativeFunction<spine_slot_data Function(spine_posed_data)>>('spine_posed_data_cast_to_slot_data');
  late final _spine_posed_data_cast_to_slot_data =
      _spine_posed_data_cast_to_slot_dataPtr.asFunction<spine_slot_data Function(spine_posed_data)>();

  spine_transform_constraint_data spine_posed_data_cast_to_transform_constraint_data(
    spine_posed_data obj,
  ) {
    return _spine_posed_data_cast_to_transform_constraint_data(
      obj,
    );
  }

  late final _spine_posed_data_cast_to_transform_constraint_dataPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_data Function(spine_posed_data)>>(
          'spine_posed_data_cast_to_transform_constraint_data');
  late final _spine_posed_data_cast_to_transform_constraint_data =
      _spine_posed_data_cast_to_transform_constraint_dataPtr
          .asFunction<spine_transform_constraint_data Function(spine_posed_data)>();

  spine_bone_pose spine_bone_local_cast_to_bone_pose(
    spine_bone_local obj,
  ) {
    return _spine_bone_local_cast_to_bone_pose(
      obj,
    );
  }

  late final _spine_bone_local_cast_to_bone_posePtr =
      _lookup<ffi.NativeFunction<spine_bone_pose Function(spine_bone_local)>>('spine_bone_local_cast_to_bone_pose');
  late final _spine_bone_local_cast_to_bone_pose =
      _spine_bone_local_cast_to_bone_posePtr.asFunction<spine_bone_pose Function(spine_bone_local)>();

  spine_bone_timeline1 spine_bone_timeline_cast_to_bone_timeline1(
    spine_bone_timeline obj,
  ) {
    return _spine_bone_timeline_cast_to_bone_timeline1(
      obj,
    );
  }

  late final _spine_bone_timeline_cast_to_bone_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline1 Function(spine_bone_timeline)>>(
          'spine_bone_timeline_cast_to_bone_timeline1');
  late final _spine_bone_timeline_cast_to_bone_timeline1 =
      _spine_bone_timeline_cast_to_bone_timeline1Ptr.asFunction<spine_bone_timeline1 Function(spine_bone_timeline)>();

  spine_bone_timeline2 spine_bone_timeline_cast_to_bone_timeline2(
    spine_bone_timeline obj,
  ) {
    return _spine_bone_timeline_cast_to_bone_timeline2(
      obj,
    );
  }

  late final _spine_bone_timeline_cast_to_bone_timeline2Ptr =
      _lookup<ffi.NativeFunction<spine_bone_timeline2 Function(spine_bone_timeline)>>(
          'spine_bone_timeline_cast_to_bone_timeline2');
  late final _spine_bone_timeline_cast_to_bone_timeline2 =
      _spine_bone_timeline_cast_to_bone_timeline2Ptr.asFunction<spine_bone_timeline2 Function(spine_bone_timeline)>();

  spine_inherit_timeline spine_bone_timeline_cast_to_inherit_timeline(
    spine_bone_timeline obj,
  ) {
    return _spine_bone_timeline_cast_to_inherit_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline_cast_to_inherit_timelinePtr =
      _lookup<ffi.NativeFunction<spine_inherit_timeline Function(spine_bone_timeline)>>(
          'spine_bone_timeline_cast_to_inherit_timeline');
  late final _spine_bone_timeline_cast_to_inherit_timeline = _spine_bone_timeline_cast_to_inherit_timelinePtr
      .asFunction<spine_inherit_timeline Function(spine_bone_timeline)>();

  spine_rotate_timeline spine_bone_timeline_cast_to_rotate_timeline(
    spine_bone_timeline obj,
  ) {
    return _spine_bone_timeline_cast_to_rotate_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline_cast_to_rotate_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rotate_timeline Function(spine_bone_timeline)>>(
          'spine_bone_timeline_cast_to_rotate_timeline');
  late final _spine_bone_timeline_cast_to_rotate_timeline =
      _spine_bone_timeline_cast_to_rotate_timelinePtr.asFunction<spine_rotate_timeline Function(spine_bone_timeline)>();

  spine_scale_timeline spine_bone_timeline_cast_to_scale_timeline(
    spine_bone_timeline obj,
  ) {
    return _spine_bone_timeline_cast_to_scale_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline_cast_to_scale_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_timeline Function(spine_bone_timeline)>>(
          'spine_bone_timeline_cast_to_scale_timeline');
  late final _spine_bone_timeline_cast_to_scale_timeline =
      _spine_bone_timeline_cast_to_scale_timelinePtr.asFunction<spine_scale_timeline Function(spine_bone_timeline)>();

  spine_scale_x_timeline spine_bone_timeline_cast_to_scale_x_timeline(
    spine_bone_timeline obj,
  ) {
    return _spine_bone_timeline_cast_to_scale_x_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline_cast_to_scale_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_x_timeline Function(spine_bone_timeline)>>(
          'spine_bone_timeline_cast_to_scale_x_timeline');
  late final _spine_bone_timeline_cast_to_scale_x_timeline = _spine_bone_timeline_cast_to_scale_x_timelinePtr
      .asFunction<spine_scale_x_timeline Function(spine_bone_timeline)>();

  spine_scale_y_timeline spine_bone_timeline_cast_to_scale_y_timeline(
    spine_bone_timeline obj,
  ) {
    return _spine_bone_timeline_cast_to_scale_y_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline_cast_to_scale_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_y_timeline Function(spine_bone_timeline)>>(
          'spine_bone_timeline_cast_to_scale_y_timeline');
  late final _spine_bone_timeline_cast_to_scale_y_timeline = _spine_bone_timeline_cast_to_scale_y_timelinePtr
      .asFunction<spine_scale_y_timeline Function(spine_bone_timeline)>();

  spine_shear_timeline spine_bone_timeline_cast_to_shear_timeline(
    spine_bone_timeline obj,
  ) {
    return _spine_bone_timeline_cast_to_shear_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline_cast_to_shear_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_timeline Function(spine_bone_timeline)>>(
          'spine_bone_timeline_cast_to_shear_timeline');
  late final _spine_bone_timeline_cast_to_shear_timeline =
      _spine_bone_timeline_cast_to_shear_timelinePtr.asFunction<spine_shear_timeline Function(spine_bone_timeline)>();

  spine_shear_x_timeline spine_bone_timeline_cast_to_shear_x_timeline(
    spine_bone_timeline obj,
  ) {
    return _spine_bone_timeline_cast_to_shear_x_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline_cast_to_shear_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_x_timeline Function(spine_bone_timeline)>>(
          'spine_bone_timeline_cast_to_shear_x_timeline');
  late final _spine_bone_timeline_cast_to_shear_x_timeline = _spine_bone_timeline_cast_to_shear_x_timelinePtr
      .asFunction<spine_shear_x_timeline Function(spine_bone_timeline)>();

  spine_shear_y_timeline spine_bone_timeline_cast_to_shear_y_timeline(
    spine_bone_timeline obj,
  ) {
    return _spine_bone_timeline_cast_to_shear_y_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline_cast_to_shear_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_y_timeline Function(spine_bone_timeline)>>(
          'spine_bone_timeline_cast_to_shear_y_timeline');
  late final _spine_bone_timeline_cast_to_shear_y_timeline = _spine_bone_timeline_cast_to_shear_y_timelinePtr
      .asFunction<spine_shear_y_timeline Function(spine_bone_timeline)>();

  spine_translate_timeline spine_bone_timeline_cast_to_translate_timeline(
    spine_bone_timeline obj,
  ) {
    return _spine_bone_timeline_cast_to_translate_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline_cast_to_translate_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_timeline Function(spine_bone_timeline)>>(
          'spine_bone_timeline_cast_to_translate_timeline');
  late final _spine_bone_timeline_cast_to_translate_timeline = _spine_bone_timeline_cast_to_translate_timelinePtr
      .asFunction<spine_translate_timeline Function(spine_bone_timeline)>();

  spine_translate_x_timeline spine_bone_timeline_cast_to_translate_x_timeline(
    spine_bone_timeline obj,
  ) {
    return _spine_bone_timeline_cast_to_translate_x_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline_cast_to_translate_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_x_timeline Function(spine_bone_timeline)>>(
          'spine_bone_timeline_cast_to_translate_x_timeline');
  late final _spine_bone_timeline_cast_to_translate_x_timeline = _spine_bone_timeline_cast_to_translate_x_timelinePtr
      .asFunction<spine_translate_x_timeline Function(spine_bone_timeline)>();

  spine_translate_y_timeline spine_bone_timeline_cast_to_translate_y_timeline(
    spine_bone_timeline obj,
  ) {
    return _spine_bone_timeline_cast_to_translate_y_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline_cast_to_translate_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_y_timeline Function(spine_bone_timeline)>>(
          'spine_bone_timeline_cast_to_translate_y_timeline');
  late final _spine_bone_timeline_cast_to_translate_y_timeline = _spine_bone_timeline_cast_to_translate_y_timelinePtr
      .asFunction<spine_translate_y_timeline Function(spine_bone_timeline)>();

  spine_bounding_box_attachment spine_vertex_attachment_cast_to_bounding_box_attachment(
    spine_vertex_attachment obj,
  ) {
    return _spine_vertex_attachment_cast_to_bounding_box_attachment(
      obj,
    );
  }

  late final _spine_vertex_attachment_cast_to_bounding_box_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_bounding_box_attachment Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_cast_to_bounding_box_attachment');
  late final _spine_vertex_attachment_cast_to_bounding_box_attachment =
      _spine_vertex_attachment_cast_to_bounding_box_attachmentPtr
          .asFunction<spine_bounding_box_attachment Function(spine_vertex_attachment)>();

  spine_clipping_attachment spine_vertex_attachment_cast_to_clipping_attachment(
    spine_vertex_attachment obj,
  ) {
    return _spine_vertex_attachment_cast_to_clipping_attachment(
      obj,
    );
  }

  late final _spine_vertex_attachment_cast_to_clipping_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_clipping_attachment Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_cast_to_clipping_attachment');
  late final _spine_vertex_attachment_cast_to_clipping_attachment =
      _spine_vertex_attachment_cast_to_clipping_attachmentPtr
          .asFunction<spine_clipping_attachment Function(spine_vertex_attachment)>();

  spine_mesh_attachment spine_vertex_attachment_cast_to_mesh_attachment(
    spine_vertex_attachment obj,
  ) {
    return _spine_vertex_attachment_cast_to_mesh_attachment(
      obj,
    );
  }

  late final _spine_vertex_attachment_cast_to_mesh_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_mesh_attachment Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_cast_to_mesh_attachment');
  late final _spine_vertex_attachment_cast_to_mesh_attachment = _spine_vertex_attachment_cast_to_mesh_attachmentPtr
      .asFunction<spine_mesh_attachment Function(spine_vertex_attachment)>();

  spine_path_attachment spine_vertex_attachment_cast_to_path_attachment(
    spine_vertex_attachment obj,
  ) {
    return _spine_vertex_attachment_cast_to_path_attachment(
      obj,
    );
  }

  late final _spine_vertex_attachment_cast_to_path_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_path_attachment Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_cast_to_path_attachment');
  late final _spine_vertex_attachment_cast_to_path_attachment = _spine_vertex_attachment_cast_to_path_attachmentPtr
      .asFunction<spine_path_attachment Function(spine_vertex_attachment)>();

  spine_bounding_box_attachment spine_attachment_cast_to_bounding_box_attachment(
    spine_attachment obj,
  ) {
    return _spine_attachment_cast_to_bounding_box_attachment(
      obj,
    );
  }

  late final _spine_attachment_cast_to_bounding_box_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_bounding_box_attachment Function(spine_attachment)>>(
          'spine_attachment_cast_to_bounding_box_attachment');
  late final _spine_attachment_cast_to_bounding_box_attachment = _spine_attachment_cast_to_bounding_box_attachmentPtr
      .asFunction<spine_bounding_box_attachment Function(spine_attachment)>();

  spine_clipping_attachment spine_attachment_cast_to_clipping_attachment(
    spine_attachment obj,
  ) {
    return _spine_attachment_cast_to_clipping_attachment(
      obj,
    );
  }

  late final _spine_attachment_cast_to_clipping_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_clipping_attachment Function(spine_attachment)>>(
          'spine_attachment_cast_to_clipping_attachment');
  late final _spine_attachment_cast_to_clipping_attachment = _spine_attachment_cast_to_clipping_attachmentPtr
      .asFunction<spine_clipping_attachment Function(spine_attachment)>();

  spine_mesh_attachment spine_attachment_cast_to_mesh_attachment(
    spine_attachment obj,
  ) {
    return _spine_attachment_cast_to_mesh_attachment(
      obj,
    );
  }

  late final _spine_attachment_cast_to_mesh_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_mesh_attachment Function(spine_attachment)>>(
          'spine_attachment_cast_to_mesh_attachment');
  late final _spine_attachment_cast_to_mesh_attachment =
      _spine_attachment_cast_to_mesh_attachmentPtr.asFunction<spine_mesh_attachment Function(spine_attachment)>();

  spine_path_attachment spine_attachment_cast_to_path_attachment(
    spine_attachment obj,
  ) {
    return _spine_attachment_cast_to_path_attachment(
      obj,
    );
  }

  late final _spine_attachment_cast_to_path_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_path_attachment Function(spine_attachment)>>(
          'spine_attachment_cast_to_path_attachment');
  late final _spine_attachment_cast_to_path_attachment =
      _spine_attachment_cast_to_path_attachmentPtr.asFunction<spine_path_attachment Function(spine_attachment)>();

  spine_point_attachment spine_attachment_cast_to_point_attachment(
    spine_attachment obj,
  ) {
    return _spine_attachment_cast_to_point_attachment(
      obj,
    );
  }

  late final _spine_attachment_cast_to_point_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_point_attachment Function(spine_attachment)>>(
          'spine_attachment_cast_to_point_attachment');
  late final _spine_attachment_cast_to_point_attachment =
      _spine_attachment_cast_to_point_attachmentPtr.asFunction<spine_point_attachment Function(spine_attachment)>();

  spine_region_attachment spine_attachment_cast_to_region_attachment(
    spine_attachment obj,
  ) {
    return _spine_attachment_cast_to_region_attachment(
      obj,
    );
  }

  late final _spine_attachment_cast_to_region_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_region_attachment Function(spine_attachment)>>(
          'spine_attachment_cast_to_region_attachment');
  late final _spine_attachment_cast_to_region_attachment =
      _spine_attachment_cast_to_region_attachmentPtr.asFunction<spine_region_attachment Function(spine_attachment)>();

  spine_vertex_attachment spine_attachment_cast_to_vertex_attachment(
    spine_attachment obj,
  ) {
    return _spine_attachment_cast_to_vertex_attachment(
      obj,
    );
  }

  late final _spine_attachment_cast_to_vertex_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_vertex_attachment Function(spine_attachment)>>(
          'spine_attachment_cast_to_vertex_attachment');
  late final _spine_attachment_cast_to_vertex_attachment =
      _spine_attachment_cast_to_vertex_attachmentPtr.asFunction<spine_vertex_attachment Function(spine_attachment)>();

  spine_constraint_timeline1 spine_constraint_timeline_cast_to_constraint_timeline1(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_constraint_timeline1(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_constraint_timeline1Ptr =
      _lookup<ffi.NativeFunction<spine_constraint_timeline1 Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_constraint_timeline1');
  late final _spine_constraint_timeline_cast_to_constraint_timeline1 =
      _spine_constraint_timeline_cast_to_constraint_timeline1Ptr
          .asFunction<spine_constraint_timeline1 Function(spine_constraint_timeline)>();

  spine_ik_constraint_timeline spine_constraint_timeline_cast_to_ik_constraint_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_ik_constraint_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_ik_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_ik_constraint_timeline');
  late final _spine_constraint_timeline_cast_to_ik_constraint_timeline =
      _spine_constraint_timeline_cast_to_ik_constraint_timelinePtr
          .asFunction<spine_ik_constraint_timeline Function(spine_constraint_timeline)>();

  spine_path_constraint_mix_timeline spine_constraint_timeline_cast_to_path_constraint_mix_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_path_constraint_mix_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_path_constraint_mix_timelinePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_mix_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_path_constraint_mix_timeline');
  late final _spine_constraint_timeline_cast_to_path_constraint_mix_timeline =
      _spine_constraint_timeline_cast_to_path_constraint_mix_timelinePtr
          .asFunction<spine_path_constraint_mix_timeline Function(spine_constraint_timeline)>();

  spine_path_constraint_position_timeline spine_constraint_timeline_cast_to_path_constraint_position_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_path_constraint_position_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_path_constraint_position_timelinePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_position_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_path_constraint_position_timeline');
  late final _spine_constraint_timeline_cast_to_path_constraint_position_timeline =
      _spine_constraint_timeline_cast_to_path_constraint_position_timelinePtr
          .asFunction<spine_path_constraint_position_timeline Function(spine_constraint_timeline)>();

  spine_path_constraint_spacing_timeline spine_constraint_timeline_cast_to_path_constraint_spacing_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_path_constraint_spacing_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_path_constraint_spacing_timelinePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_spacing_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_path_constraint_spacing_timeline');
  late final _spine_constraint_timeline_cast_to_path_constraint_spacing_timeline =
      _spine_constraint_timeline_cast_to_path_constraint_spacing_timelinePtr
          .asFunction<spine_path_constraint_spacing_timeline Function(spine_constraint_timeline)>();

  spine_physics_constraint_damping_timeline spine_constraint_timeline_cast_to_physics_constraint_damping_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_physics_constraint_damping_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_physics_constraint_damping_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_damping_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_physics_constraint_damping_timeline');
  late final _spine_constraint_timeline_cast_to_physics_constraint_damping_timeline =
      _spine_constraint_timeline_cast_to_physics_constraint_damping_timelinePtr
          .asFunction<spine_physics_constraint_damping_timeline Function(spine_constraint_timeline)>();

  spine_physics_constraint_gravity_timeline spine_constraint_timeline_cast_to_physics_constraint_gravity_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_physics_constraint_gravity_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_physics_constraint_gravity_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_gravity_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_physics_constraint_gravity_timeline');
  late final _spine_constraint_timeline_cast_to_physics_constraint_gravity_timeline =
      _spine_constraint_timeline_cast_to_physics_constraint_gravity_timelinePtr
          .asFunction<spine_physics_constraint_gravity_timeline Function(spine_constraint_timeline)>();

  spine_physics_constraint_inertia_timeline spine_constraint_timeline_cast_to_physics_constraint_inertia_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_physics_constraint_inertia_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_physics_constraint_inertia_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_inertia_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_physics_constraint_inertia_timeline');
  late final _spine_constraint_timeline_cast_to_physics_constraint_inertia_timeline =
      _spine_constraint_timeline_cast_to_physics_constraint_inertia_timelinePtr
          .asFunction<spine_physics_constraint_inertia_timeline Function(spine_constraint_timeline)>();

  spine_physics_constraint_mass_timeline spine_constraint_timeline_cast_to_physics_constraint_mass_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_physics_constraint_mass_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_physics_constraint_mass_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_mass_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_physics_constraint_mass_timeline');
  late final _spine_constraint_timeline_cast_to_physics_constraint_mass_timeline =
      _spine_constraint_timeline_cast_to_physics_constraint_mass_timelinePtr
          .asFunction<spine_physics_constraint_mass_timeline Function(spine_constraint_timeline)>();

  spine_physics_constraint_mix_timeline spine_constraint_timeline_cast_to_physics_constraint_mix_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_physics_constraint_mix_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_physics_constraint_mix_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_mix_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_physics_constraint_mix_timeline');
  late final _spine_constraint_timeline_cast_to_physics_constraint_mix_timeline =
      _spine_constraint_timeline_cast_to_physics_constraint_mix_timelinePtr
          .asFunction<spine_physics_constraint_mix_timeline Function(spine_constraint_timeline)>();

  spine_physics_constraint_reset_timeline spine_constraint_timeline_cast_to_physics_constraint_reset_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_physics_constraint_reset_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_physics_constraint_reset_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_reset_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_physics_constraint_reset_timeline');
  late final _spine_constraint_timeline_cast_to_physics_constraint_reset_timeline =
      _spine_constraint_timeline_cast_to_physics_constraint_reset_timelinePtr
          .asFunction<spine_physics_constraint_reset_timeline Function(spine_constraint_timeline)>();

  spine_physics_constraint_strength_timeline spine_constraint_timeline_cast_to_physics_constraint_strength_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_physics_constraint_strength_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_physics_constraint_strength_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_strength_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_physics_constraint_strength_timeline');
  late final _spine_constraint_timeline_cast_to_physics_constraint_strength_timeline =
      _spine_constraint_timeline_cast_to_physics_constraint_strength_timelinePtr
          .asFunction<spine_physics_constraint_strength_timeline Function(spine_constraint_timeline)>();

  spine_physics_constraint_timeline spine_constraint_timeline_cast_to_physics_constraint_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_physics_constraint_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_physics_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_physics_constraint_timeline');
  late final _spine_constraint_timeline_cast_to_physics_constraint_timeline =
      _spine_constraint_timeline_cast_to_physics_constraint_timelinePtr
          .asFunction<spine_physics_constraint_timeline Function(spine_constraint_timeline)>();

  spine_physics_constraint_wind_timeline spine_constraint_timeline_cast_to_physics_constraint_wind_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_physics_constraint_wind_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_physics_constraint_wind_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_wind_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_physics_constraint_wind_timeline');
  late final _spine_constraint_timeline_cast_to_physics_constraint_wind_timeline =
      _spine_constraint_timeline_cast_to_physics_constraint_wind_timelinePtr
          .asFunction<spine_physics_constraint_wind_timeline Function(spine_constraint_timeline)>();

  spine_slider_mix_timeline spine_constraint_timeline_cast_to_slider_mix_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_slider_mix_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_slider_mix_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slider_mix_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_slider_mix_timeline');
  late final _spine_constraint_timeline_cast_to_slider_mix_timeline =
      _spine_constraint_timeline_cast_to_slider_mix_timelinePtr
          .asFunction<spine_slider_mix_timeline Function(spine_constraint_timeline)>();

  spine_slider_timeline spine_constraint_timeline_cast_to_slider_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_slider_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_slider_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slider_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_slider_timeline');
  late final _spine_constraint_timeline_cast_to_slider_timeline = _spine_constraint_timeline_cast_to_slider_timelinePtr
      .asFunction<spine_slider_timeline Function(spine_constraint_timeline)>();

  spine_transform_constraint_timeline spine_constraint_timeline_cast_to_transform_constraint_timeline(
    spine_constraint_timeline obj,
  ) {
    return _spine_constraint_timeline_cast_to_transform_constraint_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline_cast_to_transform_constraint_timelinePtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_timeline Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_cast_to_transform_constraint_timeline');
  late final _spine_constraint_timeline_cast_to_transform_constraint_timeline =
      _spine_constraint_timeline_cast_to_transform_constraint_timelinePtr
          .asFunction<spine_transform_constraint_timeline Function(spine_constraint_timeline)>();

  spine_deform_timeline spine_slot_curve_timeline_cast_to_deform_timeline(
    spine_slot_curve_timeline obj,
  ) {
    return _spine_slot_curve_timeline_cast_to_deform_timeline(
      obj,
    );
  }

  late final _spine_slot_curve_timeline_cast_to_deform_timelinePtr =
      _lookup<ffi.NativeFunction<spine_deform_timeline Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_cast_to_deform_timeline');
  late final _spine_slot_curve_timeline_cast_to_deform_timeline = _spine_slot_curve_timeline_cast_to_deform_timelinePtr
      .asFunction<spine_deform_timeline Function(spine_slot_curve_timeline)>();

  spine_rgb2_timeline spine_slot_curve_timeline_cast_to_rgb2_timeline(
    spine_slot_curve_timeline obj,
  ) {
    return _spine_slot_curve_timeline_cast_to_rgb2_timeline(
      obj,
    );
  }

  late final _spine_slot_curve_timeline_cast_to_rgb2_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgb2_timeline Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_cast_to_rgb2_timeline');
  late final _spine_slot_curve_timeline_cast_to_rgb2_timeline = _spine_slot_curve_timeline_cast_to_rgb2_timelinePtr
      .asFunction<spine_rgb2_timeline Function(spine_slot_curve_timeline)>();

  spine_rgba2_timeline spine_slot_curve_timeline_cast_to_rgba2_timeline(
    spine_slot_curve_timeline obj,
  ) {
    return _spine_slot_curve_timeline_cast_to_rgba2_timeline(
      obj,
    );
  }

  late final _spine_slot_curve_timeline_cast_to_rgba2_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgba2_timeline Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_cast_to_rgba2_timeline');
  late final _spine_slot_curve_timeline_cast_to_rgba2_timeline = _spine_slot_curve_timeline_cast_to_rgba2_timelinePtr
      .asFunction<spine_rgba2_timeline Function(spine_slot_curve_timeline)>();

  spine_rgba_timeline spine_slot_curve_timeline_cast_to_rgba_timeline(
    spine_slot_curve_timeline obj,
  ) {
    return _spine_slot_curve_timeline_cast_to_rgba_timeline(
      obj,
    );
  }

  late final _spine_slot_curve_timeline_cast_to_rgba_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgba_timeline Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_cast_to_rgba_timeline');
  late final _spine_slot_curve_timeline_cast_to_rgba_timeline = _spine_slot_curve_timeline_cast_to_rgba_timelinePtr
      .asFunction<spine_rgba_timeline Function(spine_slot_curve_timeline)>();

  spine_rgb_timeline spine_slot_curve_timeline_cast_to_rgb_timeline(
    spine_slot_curve_timeline obj,
  ) {
    return _spine_slot_curve_timeline_cast_to_rgb_timeline(
      obj,
    );
  }

  late final _spine_slot_curve_timeline_cast_to_rgb_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rgb_timeline Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_cast_to_rgb_timeline');
  late final _spine_slot_curve_timeline_cast_to_rgb_timeline = _spine_slot_curve_timeline_cast_to_rgb_timelinePtr
      .asFunction<spine_rgb_timeline Function(spine_slot_curve_timeline)>();

  spine_from_rotate spine_from_property_cast_to_from_rotate(
    spine_from_property obj,
  ) {
    return _spine_from_property_cast_to_from_rotate(
      obj,
    );
  }

  late final _spine_from_property_cast_to_from_rotatePtr =
      _lookup<ffi.NativeFunction<spine_from_rotate Function(spine_from_property)>>(
          'spine_from_property_cast_to_from_rotate');
  late final _spine_from_property_cast_to_from_rotate =
      _spine_from_property_cast_to_from_rotatePtr.asFunction<spine_from_rotate Function(spine_from_property)>();

  spine_from_scale_x spine_from_property_cast_to_from_scale_x(
    spine_from_property obj,
  ) {
    return _spine_from_property_cast_to_from_scale_x(
      obj,
    );
  }

  late final _spine_from_property_cast_to_from_scale_xPtr =
      _lookup<ffi.NativeFunction<spine_from_scale_x Function(spine_from_property)>>(
          'spine_from_property_cast_to_from_scale_x');
  late final _spine_from_property_cast_to_from_scale_x =
      _spine_from_property_cast_to_from_scale_xPtr.asFunction<spine_from_scale_x Function(spine_from_property)>();

  spine_from_scale_y spine_from_property_cast_to_from_scale_y(
    spine_from_property obj,
  ) {
    return _spine_from_property_cast_to_from_scale_y(
      obj,
    );
  }

  late final _spine_from_property_cast_to_from_scale_yPtr =
      _lookup<ffi.NativeFunction<spine_from_scale_y Function(spine_from_property)>>(
          'spine_from_property_cast_to_from_scale_y');
  late final _spine_from_property_cast_to_from_scale_y =
      _spine_from_property_cast_to_from_scale_yPtr.asFunction<spine_from_scale_y Function(spine_from_property)>();

  spine_from_shear_y spine_from_property_cast_to_from_shear_y(
    spine_from_property obj,
  ) {
    return _spine_from_property_cast_to_from_shear_y(
      obj,
    );
  }

  late final _spine_from_property_cast_to_from_shear_yPtr =
      _lookup<ffi.NativeFunction<spine_from_shear_y Function(spine_from_property)>>(
          'spine_from_property_cast_to_from_shear_y');
  late final _spine_from_property_cast_to_from_shear_y =
      _spine_from_property_cast_to_from_shear_yPtr.asFunction<spine_from_shear_y Function(spine_from_property)>();

  spine_from_x spine_from_property_cast_to_from_x(
    spine_from_property obj,
  ) {
    return _spine_from_property_cast_to_from_x(
      obj,
    );
  }

  late final _spine_from_property_cast_to_from_xPtr =
      _lookup<ffi.NativeFunction<spine_from_x Function(spine_from_property)>>('spine_from_property_cast_to_from_x');
  late final _spine_from_property_cast_to_from_x =
      _spine_from_property_cast_to_from_xPtr.asFunction<spine_from_x Function(spine_from_property)>();

  spine_from_y spine_from_property_cast_to_from_y(
    spine_from_property obj,
  ) {
    return _spine_from_property_cast_to_from_y(
      obj,
    );
  }

  late final _spine_from_property_cast_to_from_yPtr =
      _lookup<ffi.NativeFunction<spine_from_y Function(spine_from_property)>>('spine_from_property_cast_to_from_y');
  late final _spine_from_property_cast_to_from_y =
      _spine_from_property_cast_to_from_yPtr.asFunction<spine_from_y Function(spine_from_property)>();

  spine_ik_constraint spine_ik_constraint_base_cast_to_ik_constraint(
    spine_ik_constraint_base obj,
  ) {
    return _spine_ik_constraint_base_cast_to_ik_constraint(
      obj,
    );
  }

  late final _spine_ik_constraint_base_cast_to_ik_constraintPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint Function(spine_ik_constraint_base)>>(
          'spine_ik_constraint_base_cast_to_ik_constraint');
  late final _spine_ik_constraint_base_cast_to_ik_constraint = _spine_ik_constraint_base_cast_to_ik_constraintPtr
      .asFunction<spine_ik_constraint Function(spine_ik_constraint_base)>();

  spine_ik_constraint spine_constraint_cast_to_ik_constraint(
    spine_constraint obj,
  ) {
    return _spine_constraint_cast_to_ik_constraint(
      obj,
    );
  }

  late final _spine_constraint_cast_to_ik_constraintPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint Function(spine_constraint)>>(
          'spine_constraint_cast_to_ik_constraint');
  late final _spine_constraint_cast_to_ik_constraint =
      _spine_constraint_cast_to_ik_constraintPtr.asFunction<spine_ik_constraint Function(spine_constraint)>();

  spine_ik_constraint_base spine_constraint_cast_to_ik_constraint_base(
    spine_constraint obj,
  ) {
    return _spine_constraint_cast_to_ik_constraint_base(
      obj,
    );
  }

  late final _spine_constraint_cast_to_ik_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_base Function(spine_constraint)>>(
          'spine_constraint_cast_to_ik_constraint_base');
  late final _spine_constraint_cast_to_ik_constraint_base =
      _spine_constraint_cast_to_ik_constraint_basePtr.asFunction<spine_ik_constraint_base Function(spine_constraint)>();

  spine_path_constraint spine_constraint_cast_to_path_constraint(
    spine_constraint obj,
  ) {
    return _spine_constraint_cast_to_path_constraint(
      obj,
    );
  }

  late final _spine_constraint_cast_to_path_constraintPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint Function(spine_constraint)>>(
          'spine_constraint_cast_to_path_constraint');
  late final _spine_constraint_cast_to_path_constraint =
      _spine_constraint_cast_to_path_constraintPtr.asFunction<spine_path_constraint Function(spine_constraint)>();

  spine_path_constraint_base spine_constraint_cast_to_path_constraint_base(
    spine_constraint obj,
  ) {
    return _spine_constraint_cast_to_path_constraint_base(
      obj,
    );
  }

  late final _spine_constraint_cast_to_path_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_base Function(spine_constraint)>>(
          'spine_constraint_cast_to_path_constraint_base');
  late final _spine_constraint_cast_to_path_constraint_base = _spine_constraint_cast_to_path_constraint_basePtr
      .asFunction<spine_path_constraint_base Function(spine_constraint)>();

  spine_physics_constraint spine_constraint_cast_to_physics_constraint(
    spine_constraint obj,
  ) {
    return _spine_constraint_cast_to_physics_constraint(
      obj,
    );
  }

  late final _spine_constraint_cast_to_physics_constraintPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint Function(spine_constraint)>>(
          'spine_constraint_cast_to_physics_constraint');
  late final _spine_constraint_cast_to_physics_constraint =
      _spine_constraint_cast_to_physics_constraintPtr.asFunction<spine_physics_constraint Function(spine_constraint)>();

  spine_physics_constraint_base spine_constraint_cast_to_physics_constraint_base(
    spine_constraint obj,
  ) {
    return _spine_constraint_cast_to_physics_constraint_base(
      obj,
    );
  }

  late final _spine_constraint_cast_to_physics_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_base Function(spine_constraint)>>(
          'spine_constraint_cast_to_physics_constraint_base');
  late final _spine_constraint_cast_to_physics_constraint_base = _spine_constraint_cast_to_physics_constraint_basePtr
      .asFunction<spine_physics_constraint_base Function(spine_constraint)>();

  spine_slider spine_constraint_cast_to_slider(
    spine_constraint obj,
  ) {
    return _spine_constraint_cast_to_slider(
      obj,
    );
  }

  late final _spine_constraint_cast_to_sliderPtr =
      _lookup<ffi.NativeFunction<spine_slider Function(spine_constraint)>>('spine_constraint_cast_to_slider');
  late final _spine_constraint_cast_to_slider =
      _spine_constraint_cast_to_sliderPtr.asFunction<spine_slider Function(spine_constraint)>();

  spine_slider_base spine_constraint_cast_to_slider_base(
    spine_constraint obj,
  ) {
    return _spine_constraint_cast_to_slider_base(
      obj,
    );
  }

  late final _spine_constraint_cast_to_slider_basePtr =
      _lookup<ffi.NativeFunction<spine_slider_base Function(spine_constraint)>>('spine_constraint_cast_to_slider_base');
  late final _spine_constraint_cast_to_slider_base =
      _spine_constraint_cast_to_slider_basePtr.asFunction<spine_slider_base Function(spine_constraint)>();

  spine_transform_constraint spine_constraint_cast_to_transform_constraint(
    spine_constraint obj,
  ) {
    return _spine_constraint_cast_to_transform_constraint(
      obj,
    );
  }

  late final _spine_constraint_cast_to_transform_constraintPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint Function(spine_constraint)>>(
          'spine_constraint_cast_to_transform_constraint');
  late final _spine_constraint_cast_to_transform_constraint = _spine_constraint_cast_to_transform_constraintPtr
      .asFunction<spine_transform_constraint Function(spine_constraint)>();

  spine_transform_constraint_base spine_constraint_cast_to_transform_constraint_base(
    spine_constraint obj,
  ) {
    return _spine_constraint_cast_to_transform_constraint_base(
      obj,
    );
  }

  late final _spine_constraint_cast_to_transform_constraint_basePtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_base Function(spine_constraint)>>(
          'spine_constraint_cast_to_transform_constraint_base');
  late final _spine_constraint_cast_to_transform_constraint_base =
      _spine_constraint_cast_to_transform_constraint_basePtr
          .asFunction<spine_transform_constraint_base Function(spine_constraint)>();

  spine_ik_constraint_data spine_constraint_data_cast_to_ik_constraint_data(
    spine_constraint_data obj,
  ) {
    return _spine_constraint_data_cast_to_ik_constraint_data(
      obj,
    );
  }

  late final _spine_constraint_data_cast_to_ik_constraint_dataPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_data Function(spine_constraint_data)>>(
          'spine_constraint_data_cast_to_ik_constraint_data');
  late final _spine_constraint_data_cast_to_ik_constraint_data = _spine_constraint_data_cast_to_ik_constraint_dataPtr
      .asFunction<spine_ik_constraint_data Function(spine_constraint_data)>();

  spine_path_constraint_data spine_constraint_data_cast_to_path_constraint_data(
    spine_constraint_data obj,
  ) {
    return _spine_constraint_data_cast_to_path_constraint_data(
      obj,
    );
  }

  late final _spine_constraint_data_cast_to_path_constraint_dataPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_data Function(spine_constraint_data)>>(
          'spine_constraint_data_cast_to_path_constraint_data');
  late final _spine_constraint_data_cast_to_path_constraint_data =
      _spine_constraint_data_cast_to_path_constraint_dataPtr
          .asFunction<spine_path_constraint_data Function(spine_constraint_data)>();

  spine_physics_constraint_data spine_constraint_data_cast_to_physics_constraint_data(
    spine_constraint_data obj,
  ) {
    return _spine_constraint_data_cast_to_physics_constraint_data(
      obj,
    );
  }

  late final _spine_constraint_data_cast_to_physics_constraint_dataPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_data Function(spine_constraint_data)>>(
          'spine_constraint_data_cast_to_physics_constraint_data');
  late final _spine_constraint_data_cast_to_physics_constraint_data =
      _spine_constraint_data_cast_to_physics_constraint_dataPtr
          .asFunction<spine_physics_constraint_data Function(spine_constraint_data)>();

  spine_slider_data spine_constraint_data_cast_to_slider_data(
    spine_constraint_data obj,
  ) {
    return _spine_constraint_data_cast_to_slider_data(
      obj,
    );
  }

  late final _spine_constraint_data_cast_to_slider_dataPtr =
      _lookup<ffi.NativeFunction<spine_slider_data Function(spine_constraint_data)>>(
          'spine_constraint_data_cast_to_slider_data');
  late final _spine_constraint_data_cast_to_slider_data =
      _spine_constraint_data_cast_to_slider_dataPtr.asFunction<spine_slider_data Function(spine_constraint_data)>();

  spine_transform_constraint_data spine_constraint_data_cast_to_transform_constraint_data(
    spine_constraint_data obj,
  ) {
    return _spine_constraint_data_cast_to_transform_constraint_data(
      obj,
    );
  }

  late final _spine_constraint_data_cast_to_transform_constraint_dataPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_data Function(spine_constraint_data)>>(
          'spine_constraint_data_cast_to_transform_constraint_data');
  late final _spine_constraint_data_cast_to_transform_constraint_data =
      _spine_constraint_data_cast_to_transform_constraint_dataPtr
          .asFunction<spine_transform_constraint_data Function(spine_constraint_data)>();

  spine_path_constraint spine_path_constraint_base_cast_to_path_constraint(
    spine_path_constraint_base obj,
  ) {
    return _spine_path_constraint_base_cast_to_path_constraint(
      obj,
    );
  }

  late final _spine_path_constraint_base_cast_to_path_constraintPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_cast_to_path_constraint');
  late final _spine_path_constraint_base_cast_to_path_constraint =
      _spine_path_constraint_base_cast_to_path_constraintPtr
          .asFunction<spine_path_constraint Function(spine_path_constraint_base)>();

  spine_path_constraint_position_timeline spine_constraint_timeline1_cast_to_path_constraint_position_timeline(
    spine_constraint_timeline1 obj,
  ) {
    return _spine_constraint_timeline1_cast_to_path_constraint_position_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline1_cast_to_path_constraint_position_timelinePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_position_timeline Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_cast_to_path_constraint_position_timeline');
  late final _spine_constraint_timeline1_cast_to_path_constraint_position_timeline =
      _spine_constraint_timeline1_cast_to_path_constraint_position_timelinePtr
          .asFunction<spine_path_constraint_position_timeline Function(spine_constraint_timeline1)>();

  spine_path_constraint_spacing_timeline spine_constraint_timeline1_cast_to_path_constraint_spacing_timeline(
    spine_constraint_timeline1 obj,
  ) {
    return _spine_constraint_timeline1_cast_to_path_constraint_spacing_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline1_cast_to_path_constraint_spacing_timelinePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_spacing_timeline Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_cast_to_path_constraint_spacing_timeline');
  late final _spine_constraint_timeline1_cast_to_path_constraint_spacing_timeline =
      _spine_constraint_timeline1_cast_to_path_constraint_spacing_timelinePtr
          .asFunction<spine_path_constraint_spacing_timeline Function(spine_constraint_timeline1)>();

  spine_slider_mix_timeline spine_constraint_timeline1_cast_to_slider_mix_timeline(
    spine_constraint_timeline1 obj,
  ) {
    return _spine_constraint_timeline1_cast_to_slider_mix_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline1_cast_to_slider_mix_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slider_mix_timeline Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_cast_to_slider_mix_timeline');
  late final _spine_constraint_timeline1_cast_to_slider_mix_timeline =
      _spine_constraint_timeline1_cast_to_slider_mix_timelinePtr
          .asFunction<spine_slider_mix_timeline Function(spine_constraint_timeline1)>();

  spine_slider_timeline spine_constraint_timeline1_cast_to_slider_timeline(
    spine_constraint_timeline1 obj,
  ) {
    return _spine_constraint_timeline1_cast_to_slider_timeline(
      obj,
    );
  }

  late final _spine_constraint_timeline1_cast_to_slider_timelinePtr =
      _lookup<ffi.NativeFunction<spine_slider_timeline Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_cast_to_slider_timeline');
  late final _spine_constraint_timeline1_cast_to_slider_timeline =
      _spine_constraint_timeline1_cast_to_slider_timelinePtr
          .asFunction<spine_slider_timeline Function(spine_constraint_timeline1)>();

  spine_physics_constraint spine_physics_constraint_base_cast_to_physics_constraint(
    spine_physics_constraint_base obj,
  ) {
    return _spine_physics_constraint_base_cast_to_physics_constraint(
      obj,
    );
  }

  late final _spine_physics_constraint_base_cast_to_physics_constraintPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_cast_to_physics_constraint');
  late final _spine_physics_constraint_base_cast_to_physics_constraint =
      _spine_physics_constraint_base_cast_to_physics_constraintPtr
          .asFunction<spine_physics_constraint Function(spine_physics_constraint_base)>();

  spine_physics_constraint_damping_timeline
      spine_physics_constraint_timeline_cast_to_physics_constraint_damping_timeline(
    spine_physics_constraint_timeline obj,
  ) {
    return _spine_physics_constraint_timeline_cast_to_physics_constraint_damping_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_damping_timelinePtr = _lookup<
          ffi.NativeFunction<spine_physics_constraint_damping_timeline Function(spine_physics_constraint_timeline)>>(
      'spine_physics_constraint_timeline_cast_to_physics_constraint_damping_timeline');
  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_damping_timeline =
      _spine_physics_constraint_timeline_cast_to_physics_constraint_damping_timelinePtr
          .asFunction<spine_physics_constraint_damping_timeline Function(spine_physics_constraint_timeline)>();

  spine_physics_constraint_gravity_timeline
      spine_physics_constraint_timeline_cast_to_physics_constraint_gravity_timeline(
    spine_physics_constraint_timeline obj,
  ) {
    return _spine_physics_constraint_timeline_cast_to_physics_constraint_gravity_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_gravity_timelinePtr = _lookup<
          ffi.NativeFunction<spine_physics_constraint_gravity_timeline Function(spine_physics_constraint_timeline)>>(
      'spine_physics_constraint_timeline_cast_to_physics_constraint_gravity_timeline');
  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_gravity_timeline =
      _spine_physics_constraint_timeline_cast_to_physics_constraint_gravity_timelinePtr
          .asFunction<spine_physics_constraint_gravity_timeline Function(spine_physics_constraint_timeline)>();

  spine_physics_constraint_inertia_timeline
      spine_physics_constraint_timeline_cast_to_physics_constraint_inertia_timeline(
    spine_physics_constraint_timeline obj,
  ) {
    return _spine_physics_constraint_timeline_cast_to_physics_constraint_inertia_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_inertia_timelinePtr = _lookup<
          ffi.NativeFunction<spine_physics_constraint_inertia_timeline Function(spine_physics_constraint_timeline)>>(
      'spine_physics_constraint_timeline_cast_to_physics_constraint_inertia_timeline');
  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_inertia_timeline =
      _spine_physics_constraint_timeline_cast_to_physics_constraint_inertia_timelinePtr
          .asFunction<spine_physics_constraint_inertia_timeline Function(spine_physics_constraint_timeline)>();

  spine_physics_constraint_mass_timeline spine_physics_constraint_timeline_cast_to_physics_constraint_mass_timeline(
    spine_physics_constraint_timeline obj,
  ) {
    return _spine_physics_constraint_timeline_cast_to_physics_constraint_mass_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_mass_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_mass_timeline Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_cast_to_physics_constraint_mass_timeline');
  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_mass_timeline =
      _spine_physics_constraint_timeline_cast_to_physics_constraint_mass_timelinePtr
          .asFunction<spine_physics_constraint_mass_timeline Function(spine_physics_constraint_timeline)>();

  spine_physics_constraint_mix_timeline spine_physics_constraint_timeline_cast_to_physics_constraint_mix_timeline(
    spine_physics_constraint_timeline obj,
  ) {
    return _spine_physics_constraint_timeline_cast_to_physics_constraint_mix_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_mix_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_mix_timeline Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_cast_to_physics_constraint_mix_timeline');
  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_mix_timeline =
      _spine_physics_constraint_timeline_cast_to_physics_constraint_mix_timelinePtr
          .asFunction<spine_physics_constraint_mix_timeline Function(spine_physics_constraint_timeline)>();

  spine_physics_constraint_strength_timeline
      spine_physics_constraint_timeline_cast_to_physics_constraint_strength_timeline(
    spine_physics_constraint_timeline obj,
  ) {
    return _spine_physics_constraint_timeline_cast_to_physics_constraint_strength_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_strength_timelinePtr = _lookup<
          ffi.NativeFunction<spine_physics_constraint_strength_timeline Function(spine_physics_constraint_timeline)>>(
      'spine_physics_constraint_timeline_cast_to_physics_constraint_strength_timeline');
  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_strength_timeline =
      _spine_physics_constraint_timeline_cast_to_physics_constraint_strength_timelinePtr
          .asFunction<spine_physics_constraint_strength_timeline Function(spine_physics_constraint_timeline)>();

  spine_physics_constraint_wind_timeline spine_physics_constraint_timeline_cast_to_physics_constraint_wind_timeline(
    spine_physics_constraint_timeline obj,
  ) {
    return _spine_physics_constraint_timeline_cast_to_physics_constraint_wind_timeline(
      obj,
    );
  }

  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_wind_timelinePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_wind_timeline Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_cast_to_physics_constraint_wind_timeline');
  late final _spine_physics_constraint_timeline_cast_to_physics_constraint_wind_timeline =
      _spine_physics_constraint_timeline_cast_to_physics_constraint_wind_timelinePtr
          .asFunction<spine_physics_constraint_wind_timeline Function(spine_physics_constraint_timeline)>();

  spine_rotate_timeline spine_bone_timeline1_cast_to_rotate_timeline(
    spine_bone_timeline1 obj,
  ) {
    return _spine_bone_timeline1_cast_to_rotate_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline1_cast_to_rotate_timelinePtr =
      _lookup<ffi.NativeFunction<spine_rotate_timeline Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_cast_to_rotate_timeline');
  late final _spine_bone_timeline1_cast_to_rotate_timeline = _spine_bone_timeline1_cast_to_rotate_timelinePtr
      .asFunction<spine_rotate_timeline Function(spine_bone_timeline1)>();

  spine_scale_x_timeline spine_bone_timeline1_cast_to_scale_x_timeline(
    spine_bone_timeline1 obj,
  ) {
    return _spine_bone_timeline1_cast_to_scale_x_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline1_cast_to_scale_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_x_timeline Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_cast_to_scale_x_timeline');
  late final _spine_bone_timeline1_cast_to_scale_x_timeline = _spine_bone_timeline1_cast_to_scale_x_timelinePtr
      .asFunction<spine_scale_x_timeline Function(spine_bone_timeline1)>();

  spine_scale_y_timeline spine_bone_timeline1_cast_to_scale_y_timeline(
    spine_bone_timeline1 obj,
  ) {
    return _spine_bone_timeline1_cast_to_scale_y_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline1_cast_to_scale_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_y_timeline Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_cast_to_scale_y_timeline');
  late final _spine_bone_timeline1_cast_to_scale_y_timeline = _spine_bone_timeline1_cast_to_scale_y_timelinePtr
      .asFunction<spine_scale_y_timeline Function(spine_bone_timeline1)>();

  spine_shear_x_timeline spine_bone_timeline1_cast_to_shear_x_timeline(
    spine_bone_timeline1 obj,
  ) {
    return _spine_bone_timeline1_cast_to_shear_x_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline1_cast_to_shear_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_x_timeline Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_cast_to_shear_x_timeline');
  late final _spine_bone_timeline1_cast_to_shear_x_timeline = _spine_bone_timeline1_cast_to_shear_x_timelinePtr
      .asFunction<spine_shear_x_timeline Function(spine_bone_timeline1)>();

  spine_shear_y_timeline spine_bone_timeline1_cast_to_shear_y_timeline(
    spine_bone_timeline1 obj,
  ) {
    return _spine_bone_timeline1_cast_to_shear_y_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline1_cast_to_shear_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_y_timeline Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_cast_to_shear_y_timeline');
  late final _spine_bone_timeline1_cast_to_shear_y_timeline = _spine_bone_timeline1_cast_to_shear_y_timelinePtr
      .asFunction<spine_shear_y_timeline Function(spine_bone_timeline1)>();

  spine_translate_x_timeline spine_bone_timeline1_cast_to_translate_x_timeline(
    spine_bone_timeline1 obj,
  ) {
    return _spine_bone_timeline1_cast_to_translate_x_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline1_cast_to_translate_x_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_x_timeline Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_cast_to_translate_x_timeline');
  late final _spine_bone_timeline1_cast_to_translate_x_timeline = _spine_bone_timeline1_cast_to_translate_x_timelinePtr
      .asFunction<spine_translate_x_timeline Function(spine_bone_timeline1)>();

  spine_translate_y_timeline spine_bone_timeline1_cast_to_translate_y_timeline(
    spine_bone_timeline1 obj,
  ) {
    return _spine_bone_timeline1_cast_to_translate_y_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline1_cast_to_translate_y_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_y_timeline Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_cast_to_translate_y_timeline');
  late final _spine_bone_timeline1_cast_to_translate_y_timeline = _spine_bone_timeline1_cast_to_translate_y_timelinePtr
      .asFunction<spine_translate_y_timeline Function(spine_bone_timeline1)>();

  spine_scale_timeline spine_bone_timeline2_cast_to_scale_timeline(
    spine_bone_timeline2 obj,
  ) {
    return _spine_bone_timeline2_cast_to_scale_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline2_cast_to_scale_timelinePtr =
      _lookup<ffi.NativeFunction<spine_scale_timeline Function(spine_bone_timeline2)>>(
          'spine_bone_timeline2_cast_to_scale_timeline');
  late final _spine_bone_timeline2_cast_to_scale_timeline =
      _spine_bone_timeline2_cast_to_scale_timelinePtr.asFunction<spine_scale_timeline Function(spine_bone_timeline2)>();

  spine_shear_timeline spine_bone_timeline2_cast_to_shear_timeline(
    spine_bone_timeline2 obj,
  ) {
    return _spine_bone_timeline2_cast_to_shear_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline2_cast_to_shear_timelinePtr =
      _lookup<ffi.NativeFunction<spine_shear_timeline Function(spine_bone_timeline2)>>(
          'spine_bone_timeline2_cast_to_shear_timeline');
  late final _spine_bone_timeline2_cast_to_shear_timeline =
      _spine_bone_timeline2_cast_to_shear_timelinePtr.asFunction<spine_shear_timeline Function(spine_bone_timeline2)>();

  spine_translate_timeline spine_bone_timeline2_cast_to_translate_timeline(
    spine_bone_timeline2 obj,
  ) {
    return _spine_bone_timeline2_cast_to_translate_timeline(
      obj,
    );
  }

  late final _spine_bone_timeline2_cast_to_translate_timelinePtr =
      _lookup<ffi.NativeFunction<spine_translate_timeline Function(spine_bone_timeline2)>>(
          'spine_bone_timeline2_cast_to_translate_timeline');
  late final _spine_bone_timeline2_cast_to_translate_timeline = _spine_bone_timeline2_cast_to_translate_timelinePtr
      .asFunction<spine_translate_timeline Function(spine_bone_timeline2)>();

  spine_slider spine_slider_base_cast_to_slider(
    spine_slider_base obj,
  ) {
    return _spine_slider_base_cast_to_slider(
      obj,
    );
  }

  late final _spine_slider_base_cast_to_sliderPtr =
      _lookup<ffi.NativeFunction<spine_slider Function(spine_slider_base)>>('spine_slider_base_cast_to_slider');
  late final _spine_slider_base_cast_to_slider =
      _spine_slider_base_cast_to_sliderPtr.asFunction<spine_slider Function(spine_slider_base)>();

  spine_to_rotate spine_to_property_cast_to_to_rotate(
    spine_to_property obj,
  ) {
    return _spine_to_property_cast_to_to_rotate(
      obj,
    );
  }

  late final _spine_to_property_cast_to_to_rotatePtr =
      _lookup<ffi.NativeFunction<spine_to_rotate Function(spine_to_property)>>('spine_to_property_cast_to_to_rotate');
  late final _spine_to_property_cast_to_to_rotate =
      _spine_to_property_cast_to_to_rotatePtr.asFunction<spine_to_rotate Function(spine_to_property)>();

  spine_to_scale_x spine_to_property_cast_to_to_scale_x(
    spine_to_property obj,
  ) {
    return _spine_to_property_cast_to_to_scale_x(
      obj,
    );
  }

  late final _spine_to_property_cast_to_to_scale_xPtr =
      _lookup<ffi.NativeFunction<spine_to_scale_x Function(spine_to_property)>>('spine_to_property_cast_to_to_scale_x');
  late final _spine_to_property_cast_to_to_scale_x =
      _spine_to_property_cast_to_to_scale_xPtr.asFunction<spine_to_scale_x Function(spine_to_property)>();

  spine_to_scale_y spine_to_property_cast_to_to_scale_y(
    spine_to_property obj,
  ) {
    return _spine_to_property_cast_to_to_scale_y(
      obj,
    );
  }

  late final _spine_to_property_cast_to_to_scale_yPtr =
      _lookup<ffi.NativeFunction<spine_to_scale_y Function(spine_to_property)>>('spine_to_property_cast_to_to_scale_y');
  late final _spine_to_property_cast_to_to_scale_y =
      _spine_to_property_cast_to_to_scale_yPtr.asFunction<spine_to_scale_y Function(spine_to_property)>();

  spine_to_shear_y spine_to_property_cast_to_to_shear_y(
    spine_to_property obj,
  ) {
    return _spine_to_property_cast_to_to_shear_y(
      obj,
    );
  }

  late final _spine_to_property_cast_to_to_shear_yPtr =
      _lookup<ffi.NativeFunction<spine_to_shear_y Function(spine_to_property)>>('spine_to_property_cast_to_to_shear_y');
  late final _spine_to_property_cast_to_to_shear_y =
      _spine_to_property_cast_to_to_shear_yPtr.asFunction<spine_to_shear_y Function(spine_to_property)>();

  spine_to_x spine_to_property_cast_to_to_x(
    spine_to_property obj,
  ) {
    return _spine_to_property_cast_to_to_x(
      obj,
    );
  }

  late final _spine_to_property_cast_to_to_xPtr =
      _lookup<ffi.NativeFunction<spine_to_x Function(spine_to_property)>>('spine_to_property_cast_to_to_x');
  late final _spine_to_property_cast_to_to_x =
      _spine_to_property_cast_to_to_xPtr.asFunction<spine_to_x Function(spine_to_property)>();

  spine_to_y spine_to_property_cast_to_to_y(
    spine_to_property obj,
  ) {
    return _spine_to_property_cast_to_to_y(
      obj,
    );
  }

  late final _spine_to_property_cast_to_to_yPtr =
      _lookup<ffi.NativeFunction<spine_to_y Function(spine_to_property)>>('spine_to_property_cast_to_to_y');
  late final _spine_to_property_cast_to_to_y =
      _spine_to_property_cast_to_to_yPtr.asFunction<spine_to_y Function(spine_to_property)>();

  spine_transform_constraint spine_transform_constraint_base_cast_to_transform_constraint(
    spine_transform_constraint_base obj,
  ) {
    return _spine_transform_constraint_base_cast_to_transform_constraint(
      obj,
    );
  }

  late final _spine_transform_constraint_base_cast_to_transform_constraintPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_cast_to_transform_constraint');
  late final _spine_transform_constraint_base_cast_to_transform_constraint =
      _spine_transform_constraint_base_cast_to_transform_constraintPtr
          .asFunction<spine_transform_constraint Function(spine_transform_constraint_base)>();

  spine_alpha_timeline spine_alpha_timeline_create(
    int frameCount,
    int bezierCount,
    int slotIndex,
  ) {
    return _spine_alpha_timeline_create(
      frameCount,
      bezierCount,
      slotIndex,
    );
  }

  late final _spine_alpha_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_alpha_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_alpha_timeline_create');
  late final _spine_alpha_timeline_create =
      _spine_alpha_timeline_createPtr.asFunction<spine_alpha_timeline Function(int, int, int)>();

  void spine_alpha_timeline_dispose(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_dispose(
      self,
    );
  }

  late final _spine_alpha_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_alpha_timeline)>>('spine_alpha_timeline_dispose');
  late final _spine_alpha_timeline_dispose =
      _spine_alpha_timeline_disposePtr.asFunction<void Function(spine_alpha_timeline)>();

  spine_rtti spine_alpha_timeline_get_rtti(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_rtti(
      self,
    );
  }

  late final _spine_alpha_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_alpha_timeline)>>('spine_alpha_timeline_get_rtti');
  late final _spine_alpha_timeline_get_rtti =
      _spine_alpha_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_alpha_timeline)>();

  void spine_alpha_timeline_apply(
    spine_alpha_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_alpha_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_alpha_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_alpha_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_alpha_timeline_apply');
  late final _spine_alpha_timeline_apply = _spine_alpha_timeline_applyPtr.asFunction<
      void Function(spine_alpha_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_alpha_timeline_get_slot_index(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_alpha_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_alpha_timeline)>>('spine_alpha_timeline_get_slot_index');
  late final _spine_alpha_timeline_get_slot_index =
      _spine_alpha_timeline_get_slot_indexPtr.asFunction<int Function(spine_alpha_timeline)>();

  void spine_alpha_timeline_set_slot_index(
    spine_alpha_timeline self,
    int inValue,
  ) {
    return _spine_alpha_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_alpha_timeline_set_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_alpha_timeline, ffi.Int)>>(
          'spine_alpha_timeline_set_slot_index');
  late final _spine_alpha_timeline_set_slot_index =
      _spine_alpha_timeline_set_slot_indexPtr.asFunction<void Function(spine_alpha_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_alpha_timeline_set_frame(
    spine_alpha_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_alpha_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_alpha_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_alpha_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_alpha_timeline_set_frame');
  late final _spine_alpha_timeline_set_frame =
      _spine_alpha_timeline_set_framePtr.asFunction<void Function(spine_alpha_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_alpha_timeline_get_curve_value(
    spine_alpha_timeline self,
    double time,
  ) {
    return _spine_alpha_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_alpha_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_alpha_timeline, ffi.Float)>>(
          'spine_alpha_timeline_get_curve_value');
  late final _spine_alpha_timeline_get_curve_value =
      _spine_alpha_timeline_get_curve_valuePtr.asFunction<double Function(spine_alpha_timeline, double)>();

  double spine_alpha_timeline_get_relative_value(
    spine_alpha_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_alpha_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_alpha_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_alpha_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_alpha_timeline_get_relative_value');
  late final _spine_alpha_timeline_get_relative_value = _spine_alpha_timeline_get_relative_valuePtr
      .asFunction<double Function(spine_alpha_timeline, double, double, int, double, double)>();

  double spine_alpha_timeline_get_absolute_value_1(
    spine_alpha_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_alpha_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_alpha_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_alpha_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_alpha_timeline_get_absolute_value_1');
  late final _spine_alpha_timeline_get_absolute_value_1 = _spine_alpha_timeline_get_absolute_value_1Ptr
      .asFunction<double Function(spine_alpha_timeline, double, double, int, double, double)>();

  double spine_alpha_timeline_get_absolute_value_2(
    spine_alpha_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_alpha_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_alpha_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_alpha_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_alpha_timeline_get_absolute_value_2');
  late final _spine_alpha_timeline_get_absolute_value_2 = _spine_alpha_timeline_get_absolute_value_2Ptr
      .asFunction<double Function(spine_alpha_timeline, double, double, int, double, double, double)>();

  double spine_alpha_timeline_get_scale_value(
    spine_alpha_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_alpha_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_alpha_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_alpha_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_alpha_timeline_get_scale_value');
  late final _spine_alpha_timeline_get_scale_value = _spine_alpha_timeline_get_scale_valuePtr
      .asFunction<double Function(spine_alpha_timeline, double, double, int, int, double, double)>();

  void spine_alpha_timeline_set_linear(
    spine_alpha_timeline self,
    int frame,
  ) {
    return _spine_alpha_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_alpha_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_alpha_timeline, ffi.Size)>>('spine_alpha_timeline_set_linear');
  late final _spine_alpha_timeline_set_linear =
      _spine_alpha_timeline_set_linearPtr.asFunction<void Function(spine_alpha_timeline, int)>();

  void spine_alpha_timeline_set_stepped(
    spine_alpha_timeline self,
    int frame,
  ) {
    return _spine_alpha_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_alpha_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_alpha_timeline, ffi.Size)>>(
          'spine_alpha_timeline_set_stepped');
  late final _spine_alpha_timeline_set_stepped =
      _spine_alpha_timeline_set_steppedPtr.asFunction<void Function(spine_alpha_timeline, int)>();

  void spine_alpha_timeline_set_bezier(
    spine_alpha_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_alpha_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_alpha_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_alpha_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_alpha_timeline_set_bezier');
  late final _spine_alpha_timeline_set_bezier = _spine_alpha_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_alpha_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_alpha_timeline_get_bezier_value(
    spine_alpha_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_alpha_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_alpha_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_alpha_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_alpha_timeline_get_bezier_value');
  late final _spine_alpha_timeline_get_bezier_value = _spine_alpha_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_alpha_timeline, double, int, int, int)>();

  spine_array_float spine_alpha_timeline_get_curves(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_curves(
      self,
    );
  }

  late final _spine_alpha_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_alpha_timeline)>>('spine_alpha_timeline_get_curves');
  late final _spine_alpha_timeline_get_curves =
      _spine_alpha_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_alpha_timeline)>();

  int spine_alpha_timeline_get_frame_entries(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_alpha_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_alpha_timeline)>>('spine_alpha_timeline_get_frame_entries');
  late final _spine_alpha_timeline_get_frame_entries =
      _spine_alpha_timeline_get_frame_entriesPtr.asFunction<int Function(spine_alpha_timeline)>();

  int spine_alpha_timeline_get_frame_count(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_alpha_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_alpha_timeline)>>('spine_alpha_timeline_get_frame_count');
  late final _spine_alpha_timeline_get_frame_count =
      _spine_alpha_timeline_get_frame_countPtr.asFunction<int Function(spine_alpha_timeline)>();

  spine_array_float spine_alpha_timeline_get_frames(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_frames(
      self,
    );
  }

  late final _spine_alpha_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_alpha_timeline)>>('spine_alpha_timeline_get_frames');
  late final _spine_alpha_timeline_get_frames =
      _spine_alpha_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_alpha_timeline)>();

  double spine_alpha_timeline_get_duration(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_duration(
      self,
    );
  }

  late final _spine_alpha_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_alpha_timeline)>>('spine_alpha_timeline_get_duration');
  late final _spine_alpha_timeline_get_duration =
      _spine_alpha_timeline_get_durationPtr.asFunction<double Function(spine_alpha_timeline)>();

  spine_array_property_id spine_alpha_timeline_get_property_ids(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_alpha_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_alpha_timeline)>>(
          'spine_alpha_timeline_get_property_ids');
  late final _spine_alpha_timeline_get_property_ids =
      _spine_alpha_timeline_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_alpha_timeline)>();

  spine_rtti spine_alpha_timeline_rtti() {
    return _spine_alpha_timeline_rtti();
  }

  late final _spine_alpha_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_alpha_timeline_rtti');
  late final _spine_alpha_timeline_rtti = _spine_alpha_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_animation spine_animation_create(
    ffi.Pointer<ffi.Char> name,
    spine_array_timeline timelines,
    double duration,
  ) {
    return _spine_animation_create(
      name,
      timelines,
      duration,
    );
  }

  late final _spine_animation_createPtr =
      _lookup<ffi.NativeFunction<spine_animation Function(ffi.Pointer<ffi.Char>, spine_array_timeline, ffi.Float)>>(
          'spine_animation_create');
  late final _spine_animation_create = _spine_animation_createPtr
      .asFunction<spine_animation Function(ffi.Pointer<ffi.Char>, spine_array_timeline, double)>();

  void spine_animation_dispose(
    spine_animation self,
  ) {
    return _spine_animation_dispose(
      self,
    );
  }

  late final _spine_animation_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation)>>('spine_animation_dispose');
  late final _spine_animation_dispose = _spine_animation_disposePtr.asFunction<void Function(spine_animation)>();

  /// If the returned array or the timelines it contains are modified,
  /// setTimelines() must be called.
  spine_array_timeline spine_animation_get_timelines(
    spine_animation self,
  ) {
    return _spine_animation_get_timelines(
      self,
    );
  }

  late final _spine_animation_get_timelinesPtr =
      _lookup<ffi.NativeFunction<spine_array_timeline Function(spine_animation)>>('spine_animation_get_timelines');
  late final _spine_animation_get_timelines =
      _spine_animation_get_timelinesPtr.asFunction<spine_array_timeline Function(spine_animation)>();

  void spine_animation_set_timelines(
    spine_animation self,
    spine_array_timeline timelines,
  ) {
    return _spine_animation_set_timelines(
      self,
      timelines,
    );
  }

  late final _spine_animation_set_timelinesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation, spine_array_timeline)>>(
          'spine_animation_set_timelines');
  late final _spine_animation_set_timelines =
      _spine_animation_set_timelinesPtr.asFunction<void Function(spine_animation, spine_array_timeline)>();

  /// Returns true if this animation contains a timeline with any of the specified
  /// property IDs.
  bool spine_animation_has_timeline(
    spine_animation self,
    spine_array_property_id ids,
  ) {
    return _spine_animation_has_timeline(
      self,
      ids,
    );
  }

  late final _spine_animation_has_timelinePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_animation, spine_array_property_id)>>(
          'spine_animation_has_timeline');
  late final _spine_animation_has_timeline =
      _spine_animation_has_timelinePtr.asFunction<bool Function(spine_animation, spine_array_property_id)>();

  /// The duration of the animation in seconds, which is usually the highest time
  /// of all frames in the timeline. The duration is used to know when it has
  /// completed and when it should loop back to the start.
  double spine_animation_get_duration(
    spine_animation self,
  ) {
    return _spine_animation_get_duration(
      self,
    );
  }

  late final _spine_animation_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_animation)>>('spine_animation_get_duration');
  late final _spine_animation_get_duration =
      _spine_animation_get_durationPtr.asFunction<double Function(spine_animation)>();

  void spine_animation_set_duration(
    spine_animation self,
    double inValue,
  ) {
    return _spine_animation_set_duration(
      self,
      inValue,
    );
  }

  late final _spine_animation_set_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation, ffi.Float)>>('spine_animation_set_duration');
  late final _spine_animation_set_duration =
      _spine_animation_set_durationPtr.asFunction<void Function(spine_animation, double)>();

  /// Applies the animation's timelines to the specified skeleton.
  ///
  /// See Timeline::apply().
  ///
  /// @param skeleton The skeleton the animation is being applied to. This provides access to the bones, slots, and other skeleton components the timelines may change.
  /// @param lastTime The last time in seconds this animation was applied. Some timelines trigger only at specific times rather than every frame. Pass -1 the first time an animation is applied to ensure frame 0 is triggered.
  /// @param time The time in seconds the skeleton is being posed for. Most timelines find the frame before and the frame after this time and interpolate between the frame values. If beyond the getDuration() and loop is true then the animation will repeat, else the last frame will be applied.
  /// @param loop If true, the animation repeats after the getDuration().
  /// @param events If any events are fired, they are added to this list. Can be null to ignore fired events or if no timelines fire events.
  /// @param alpha 0 applies the current or setup values (depending on blend). 1 applies the timeline values. Between 0 and 1 applies values between the current or setup values and the timeline values. By adjusting alpha over time, an animation can be mixed in or out. alpha can also be useful to apply animations on top of each other (layering).
  /// @param blend Controls how mixing is applied when alpha < 1.
  /// @param direction Indicates whether the timelines are mixing in or out. Used by timelines which perform instant transitions, such as DrawOrderTimeline or AttachmentTimeline.
  void spine_animation_apply(
    spine_animation self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    bool loop,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_animation_apply(
      self,
      skeleton,
      lastTime,
      time,
      loop,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_animation_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_animation, spine_skeleton, ffi.Float, ffi.Float, ffi.Bool, spine_array_event,
              ffi.Float, ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_animation_apply');
  late final _spine_animation_apply = _spine_animation_applyPtr.asFunction<
      void Function(
          spine_animation, spine_skeleton, double, double, bool, spine_array_event, double, int, int, bool)>();

  /// The animation's name, which is unique across all animations in the skeleton.
  ffi.Pointer<ffi.Char> spine_animation_get_name(
    spine_animation self,
  ) {
    return _spine_animation_get_name(
      self,
    );
  }

  late final _spine_animation_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_animation)>>('spine_animation_get_name');
  late final _spine_animation_get_name =
      _spine_animation_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_animation)>();

  /// The bone indices affected by this animation.
  spine_array_int spine_animation_get_bones(
    spine_animation self,
  ) {
    return _spine_animation_get_bones(
      self,
    );
  }

  late final _spine_animation_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_int Function(spine_animation)>>('spine_animation_get_bones');
  late final _spine_animation_get_bones =
      _spine_animation_get_bonesPtr.asFunction<spine_array_int Function(spine_animation)>();

  /// @param target After the first and before the last entry.
  int spine_animation_search_1(
    spine_array_float values,
    double target,
  ) {
    return _spine_animation_search_1(
      values,
      target,
    );
  }

  late final _spine_animation_search_1Ptr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_float, ffi.Float)>>('spine_animation_search_1');
  late final _spine_animation_search_1 =
      _spine_animation_search_1Ptr.asFunction<int Function(spine_array_float, double)>();

  int spine_animation_search_2(
    spine_array_float values,
    double target,
    int step,
  ) {
    return _spine_animation_search_2(
      values,
      target,
      step,
    );
  }

  late final _spine_animation_search_2Ptr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_array_float, ffi.Float, ffi.Int)>>('spine_animation_search_2');
  late final _spine_animation_search_2 =
      _spine_animation_search_2Ptr.asFunction<int Function(spine_array_float, double, int)>();

  spine_animation_state spine_animation_state_create(
    spine_animation_state_data data,
  ) {
    return _spine_animation_state_create(
      data,
    );
  }

  late final _spine_animation_state_createPtr =
      _lookup<ffi.NativeFunction<spine_animation_state Function(spine_animation_state_data)>>(
          'spine_animation_state_create');
  late final _spine_animation_state_create =
      _spine_animation_state_createPtr.asFunction<spine_animation_state Function(spine_animation_state_data)>();

  void spine_animation_state_dispose(
    spine_animation_state self,
  ) {
    return _spine_animation_state_dispose(
      self,
    );
  }

  late final _spine_animation_state_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state)>>('spine_animation_state_dispose');
  late final _spine_animation_state_dispose =
      _spine_animation_state_disposePtr.asFunction<void Function(spine_animation_state)>();

  /// Increments each track entry TrackEntry::getTrackTime(), setting queued
  /// animations as current if needed.
  void spine_animation_state_update(
    spine_animation_state self,
    double delta,
  ) {
    return _spine_animation_state_update(
      self,
      delta,
    );
  }

  late final _spine_animation_state_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state, ffi.Float)>>('spine_animation_state_update');
  late final _spine_animation_state_update =
      _spine_animation_state_updatePtr.asFunction<void Function(spine_animation_state, double)>();

  /// Poses the skeleton using the track entry animations. The animation state is
  /// not changed, so can be applied to multiple skeletons to pose them
  /// identically.
  ///
  /// @return True if any animations were applied.
  bool spine_animation_state_apply(
    spine_animation_state self,
    spine_skeleton skeleton,
  ) {
    return _spine_animation_state_apply(
      self,
      skeleton,
    );
  }

  late final _spine_animation_state_applyPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_animation_state, spine_skeleton)>>(
          'spine_animation_state_apply');
  late final _spine_animation_state_apply =
      _spine_animation_state_applyPtr.asFunction<bool Function(spine_animation_state, spine_skeleton)>();

  /// Removes all animations from all tracks, leaving skeletons in their current
  /// pose.
  ///
  /// It may be desired to use AnimationState::setEmptyAnimations(float) to mix the
  /// skeletons back to the setup pose, rather than leaving them in their current
  /// pose.
  void spine_animation_state_clear_tracks(
    spine_animation_state self,
  ) {
    return _spine_animation_state_clear_tracks(
      self,
    );
  }

  late final _spine_animation_state_clear_tracksPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state)>>('spine_animation_state_clear_tracks');
  late final _spine_animation_state_clear_tracks =
      _spine_animation_state_clear_tracksPtr.asFunction<void Function(spine_animation_state)>();

  /// Removes all animations from the track, leaving skeletons in their current
  /// pose.
  ///
  /// It may be desired to use AnimationState::setEmptyAnimation(int, float) to mix
  /// the skeletons back to the setup pose, rather than leaving them in their
  /// current pose.
  void spine_animation_state_clear_track(
    spine_animation_state self,
    int trackIndex,
  ) {
    return _spine_animation_state_clear_track(
      self,
      trackIndex,
    );
  }

  late final _spine_animation_state_clear_trackPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state, ffi.Size)>>(
          'spine_animation_state_clear_track');
  late final _spine_animation_state_clear_track =
      _spine_animation_state_clear_trackPtr.asFunction<void Function(spine_animation_state, int)>();

  /// Sets an animation by name.
  ///
  /// See setAnimation(int, Animation, bool).
  spine_track_entry spine_animation_state_set_animation_1(
    spine_animation_state self,
    int trackIndex,
    ffi.Pointer<ffi.Char> animationName,
    bool loop,
  ) {
    return _spine_animation_state_set_animation_1(
      self,
      trackIndex,
      animationName,
      loop,
    );
  }

  late final _spine_animation_state_set_animation_1Ptr = _lookup<
      ffi.NativeFunction<
          spine_track_entry Function(spine_animation_state, ffi.Size, ffi.Pointer<ffi.Char>,
              ffi.Bool)>>('spine_animation_state_set_animation_1');
  late final _spine_animation_state_set_animation_1 = _spine_animation_state_set_animation_1Ptr
      .asFunction<spine_track_entry Function(spine_animation_state, int, ffi.Pointer<ffi.Char>, bool)>();

  /// Sets the current animation for a track, discarding any queued animations.
  ///
  /// If the formerly current track entry is for the same animation and was never
  /// applied to a skeleton, it is replaced (not mixed from).
  ///
  /// @param loop If true, the animation will repeat. If false, it will not, instead its last frame is applied if played beyond its duration. In either case TrackEntry.TrackEnd determines when the track is cleared.
  ///
  /// @return A track entry to allow further customization of animation playback. References to the track entry must not be kept after AnimationState.Dispose.
  spine_track_entry spine_animation_state_set_animation_2(
    spine_animation_state self,
    int trackIndex,
    spine_animation animation,
    bool loop,
  ) {
    return _spine_animation_state_set_animation_2(
      self,
      trackIndex,
      animation,
      loop,
    );
  }

  late final _spine_animation_state_set_animation_2Ptr = _lookup<
          ffi.NativeFunction<spine_track_entry Function(spine_animation_state, ffi.Size, spine_animation, ffi.Bool)>>(
      'spine_animation_state_set_animation_2');
  late final _spine_animation_state_set_animation_2 = _spine_animation_state_set_animation_2Ptr
      .asFunction<spine_track_entry Function(spine_animation_state, int, spine_animation, bool)>();

  /// Queues an animation by name.
  ///
  /// See addAnimation(int, Animation, bool, float).
  spine_track_entry spine_animation_state_add_animation_1(
    spine_animation_state self,
    int trackIndex,
    ffi.Pointer<ffi.Char> animationName,
    bool loop,
    double delay,
  ) {
    return _spine_animation_state_add_animation_1(
      self,
      trackIndex,
      animationName,
      loop,
      delay,
    );
  }

  late final _spine_animation_state_add_animation_1Ptr = _lookup<
      ffi.NativeFunction<
          spine_track_entry Function(spine_animation_state, ffi.Size, ffi.Pointer<ffi.Char>, ffi.Bool,
              ffi.Float)>>('spine_animation_state_add_animation_1');
  late final _spine_animation_state_add_animation_1 = _spine_animation_state_add_animation_1Ptr
      .asFunction<spine_track_entry Function(spine_animation_state, int, ffi.Pointer<ffi.Char>, bool, double)>();

  /// Adds an animation to be played delay seconds after the current or last queued
  /// animation for a track. If the track has no entries, this is equivalent to
  /// calling setAnimation.
  ///
  /// @param delay Seconds to begin this animation after the start of the previous animation. May be < = 0 to use the animation duration of the previous track minus any mix duration plus the negative delay.
  ///
  /// @return A track entry to allow further customization of animation playback. References to the track entry must not be kept after AnimationState.Dispose
  spine_track_entry spine_animation_state_add_animation_2(
    spine_animation_state self,
    int trackIndex,
    spine_animation animation,
    bool loop,
    double delay,
  ) {
    return _spine_animation_state_add_animation_2(
      self,
      trackIndex,
      animation,
      loop,
      delay,
    );
  }

  late final _spine_animation_state_add_animation_2Ptr = _lookup<
      ffi.NativeFunction<
          spine_track_entry Function(spine_animation_state, ffi.Size, spine_animation, ffi.Bool,
              ffi.Float)>>('spine_animation_state_add_animation_2');
  late final _spine_animation_state_add_animation_2 = _spine_animation_state_add_animation_2Ptr
      .asFunction<spine_track_entry Function(spine_animation_state, int, spine_animation, bool, double)>();

  /// Sets an empty animation for a track, discarding any queued animations, and
  /// sets the track entry's TrackEntry::getMixDuration(). An empty animation has
  /// no timelines and serves as a placeholder for mixing in or out.
  ///
  /// Mixing out is done by setting an empty animation with a mix duration using
  /// either setEmptyAnimation(int, float), setEmptyAnimations(float), or
  /// addEmptyAnimation(int, float, float). Mixing to an empty animation causes the
  /// previous animation to be applied less and less over the mix duration.
  /// Properties keyed in the previous animation transition to the value from lower
  /// tracks or to the setup pose value if no lower tracks key the property. A mix
  /// duration of 0 still mixes out over one frame.
  ///
  /// Mixing in is done by first setting an empty animation, then adding an
  /// animation using addAnimation(int, Animation, bool, float) with the desired
  /// delay (an empty animation has a duration of 0) and on the returned track
  /// entry, set the TrackEntry::setMixDuration(float). Mixing from an empty
  /// animation causes the new animation to be applied more and more over the mix
  /// duration. Properties keyed in the new animation transition from the value
  /// from lower tracks or from the setup pose value if no lower tracks key the
  /// property to the value keyed in the new animation.
  ///
  /// See Empty animations in the Spine Runtimes Guide.
  spine_track_entry spine_animation_state_set_empty_animation(
    spine_animation_state self,
    int trackIndex,
    double mixDuration,
  ) {
    return _spine_animation_state_set_empty_animation(
      self,
      trackIndex,
      mixDuration,
    );
  }

  late final _spine_animation_state_set_empty_animationPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function(spine_animation_state, ffi.Size, ffi.Float)>>(
          'spine_animation_state_set_empty_animation');
  late final _spine_animation_state_set_empty_animation = _spine_animation_state_set_empty_animationPtr
      .asFunction<spine_track_entry Function(spine_animation_state, int, double)>();

  /// Adds an empty animation to be played after the current or last queued
  /// animation for a track, and sets the track entry's
  /// TrackEntry::getMixDuration(). If the track has no entries, it is equivalent
  /// to calling setEmptyAnimation(int, float).
  ///
  /// See setEmptyAnimation(int, float) and Empty animations in the Spine Runtimes
  /// Guide.
  ///
  /// @param delay If > 0, sets TrackEntry::getDelay(). If < = 0, the delay set is the duration of the previous track entry minus any mix duration plus the specified delay (ie the mix ends at ( delay = 0) or before ( delay < 0) the previous track entry duration). If the previous entry is looping, its next loop completion is used instead of its duration.
  ///
  /// @return A track entry to allow further customization of animation playback. References to the track entry must not be kept after the AnimationStateListener::dispose(TrackEntry) event occurs.
  spine_track_entry spine_animation_state_add_empty_animation(
    spine_animation_state self,
    int trackIndex,
    double mixDuration,
    double delay,
  ) {
    return _spine_animation_state_add_empty_animation(
      self,
      trackIndex,
      mixDuration,
      delay,
    );
  }

  late final _spine_animation_state_add_empty_animationPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function(spine_animation_state, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_animation_state_add_empty_animation');
  late final _spine_animation_state_add_empty_animation = _spine_animation_state_add_empty_animationPtr
      .asFunction<spine_track_entry Function(spine_animation_state, int, double, double)>();

  /// Sets an empty animation for every track, discarding any queued animations,
  /// and mixes to it over the specified mix duration.
  ///
  /// See Empty animations in the Spine Runtimes Guide.
  void spine_animation_state_set_empty_animations(
    spine_animation_state self,
    double mixDuration,
  ) {
    return _spine_animation_state_set_empty_animations(
      self,
      mixDuration,
    );
  }

  late final _spine_animation_state_set_empty_animationsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state, ffi.Float)>>(
          'spine_animation_state_set_empty_animations');
  late final _spine_animation_state_set_empty_animations =
      _spine_animation_state_set_empty_animationsPtr.asFunction<void Function(spine_animation_state, double)>();

  spine_track_entry spine_animation_state_get_current(
    spine_animation_state self,
    int trackIndex,
  ) {
    return _spine_animation_state_get_current(
      self,
      trackIndex,
    );
  }

  late final _spine_animation_state_get_currentPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function(spine_animation_state, ffi.Size)>>(
          'spine_animation_state_get_current');
  late final _spine_animation_state_get_current =
      _spine_animation_state_get_currentPtr.asFunction<spine_track_entry Function(spine_animation_state, int)>();

  /// The AnimationStateData to look up mix durations.
  spine_animation_state_data spine_animation_state_get_data(
    spine_animation_state self,
  ) {
    return _spine_animation_state_get_data(
      self,
    );
  }

  late final _spine_animation_state_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_animation_state_data Function(spine_animation_state)>>(
          'spine_animation_state_get_data');
  late final _spine_animation_state_get_data =
      _spine_animation_state_get_dataPtr.asFunction<spine_animation_state_data Function(spine_animation_state)>();

  /// The list of tracks that have had animations, which may contain null entries
  /// for tracks that currently have no animation.
  spine_array_track_entry spine_animation_state_get_tracks(
    spine_animation_state self,
  ) {
    return _spine_animation_state_get_tracks(
      self,
    );
  }

  late final _spine_animation_state_get_tracksPtr =
      _lookup<ffi.NativeFunction<spine_array_track_entry Function(spine_animation_state)>>(
          'spine_animation_state_get_tracks');
  late final _spine_animation_state_get_tracks =
      _spine_animation_state_get_tracksPtr.asFunction<spine_array_track_entry Function(spine_animation_state)>();

  /// Multiplier for the delta time when the animation state is updated, causing
  /// time for all animations and mixes to play slower or faster. Defaults to 1.
  ///
  /// See TrackEntry TrackEntry::getTimeScale() for affecting a single animation.
  double spine_animation_state_get_time_scale(
    spine_animation_state self,
  ) {
    return _spine_animation_state_get_time_scale(
      self,
    );
  }

  late final _spine_animation_state_get_time_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_animation_state)>>('spine_animation_state_get_time_scale');
  late final _spine_animation_state_get_time_scale =
      _spine_animation_state_get_time_scalePtr.asFunction<double Function(spine_animation_state)>();

  void spine_animation_state_set_time_scale(
    spine_animation_state self,
    double inValue,
  ) {
    return _spine_animation_state_set_time_scale(
      self,
      inValue,
    );
  }

  late final _spine_animation_state_set_time_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state, ffi.Float)>>(
          'spine_animation_state_set_time_scale');
  late final _spine_animation_state_set_time_scale =
      _spine_animation_state_set_time_scalePtr.asFunction<void Function(spine_animation_state, double)>();

  void spine_animation_state_disable_queue(
    spine_animation_state self,
  ) {
    return _spine_animation_state_disable_queue(
      self,
    );
  }

  late final _spine_animation_state_disable_queuePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state)>>('spine_animation_state_disable_queue');
  late final _spine_animation_state_disable_queue =
      _spine_animation_state_disable_queuePtr.asFunction<void Function(spine_animation_state)>();

  void spine_animation_state_enable_queue(
    spine_animation_state self,
  ) {
    return _spine_animation_state_enable_queue(
      self,
    );
  }

  late final _spine_animation_state_enable_queuePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state)>>('spine_animation_state_enable_queue');
  late final _spine_animation_state_enable_queue =
      _spine_animation_state_enable_queuePtr.asFunction<void Function(spine_animation_state)>();

  void spine_animation_state_set_manual_track_entry_disposal(
    spine_animation_state self,
    bool inValue,
  ) {
    return _spine_animation_state_set_manual_track_entry_disposal(
      self,
      inValue,
    );
  }

  late final _spine_animation_state_set_manual_track_entry_disposalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state, ffi.Bool)>>(
          'spine_animation_state_set_manual_track_entry_disposal');
  late final _spine_animation_state_set_manual_track_entry_disposal =
      _spine_animation_state_set_manual_track_entry_disposalPtr
          .asFunction<void Function(spine_animation_state, bool)>();

  bool spine_animation_state_get_manual_track_entry_disposal(
    spine_animation_state self,
  ) {
    return _spine_animation_state_get_manual_track_entry_disposal(
      self,
    );
  }

  late final _spine_animation_state_get_manual_track_entry_disposalPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_animation_state)>>(
          'spine_animation_state_get_manual_track_entry_disposal');
  late final _spine_animation_state_get_manual_track_entry_disposal =
      _spine_animation_state_get_manual_track_entry_disposalPtr.asFunction<bool Function(spine_animation_state)>();

  void spine_animation_state_dispose_track_entry(
    spine_animation_state self,
    spine_track_entry entry,
  ) {
    return _spine_animation_state_dispose_track_entry(
      self,
      entry,
    );
  }

  late final _spine_animation_state_dispose_track_entryPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state, spine_track_entry)>>(
          'spine_animation_state_dispose_track_entry');
  late final _spine_animation_state_dispose_track_entry = _spine_animation_state_dispose_track_entryPtr
      .asFunction<void Function(spine_animation_state, spine_track_entry)>();

  ffi.Pointer<ffi.Void> spine_animation_state_get_renderer_object(
    spine_animation_state self,
  ) {
    return _spine_animation_state_get_renderer_object(
      self,
    );
  }

  late final _spine_animation_state_get_renderer_objectPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(spine_animation_state)>>(
          'spine_animation_state_get_renderer_object');
  late final _spine_animation_state_get_renderer_object =
      _spine_animation_state_get_renderer_objectPtr.asFunction<ffi.Pointer<ffi.Void> Function(spine_animation_state)>();

  spine_animation_state_data spine_animation_state_data_create(
    spine_skeleton_data skeletonData,
  ) {
    return _spine_animation_state_data_create(
      skeletonData,
    );
  }

  late final _spine_animation_state_data_createPtr =
      _lookup<ffi.NativeFunction<spine_animation_state_data Function(spine_skeleton_data)>>(
          'spine_animation_state_data_create');
  late final _spine_animation_state_data_create =
      _spine_animation_state_data_createPtr.asFunction<spine_animation_state_data Function(spine_skeleton_data)>();

  void spine_animation_state_data_dispose(
    spine_animation_state_data self,
  ) {
    return _spine_animation_state_data_dispose(
      self,
    );
  }

  late final _spine_animation_state_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state_data)>>('spine_animation_state_data_dispose');
  late final _spine_animation_state_data_dispose =
      _spine_animation_state_data_disposePtr.asFunction<void Function(spine_animation_state_data)>();

  /// The SkeletonData to look up animations when they are specified by name.
  spine_skeleton_data spine_animation_state_data_get_skeleton_data(
    spine_animation_state_data self,
  ) {
    return _spine_animation_state_data_get_skeleton_data(
      self,
    );
  }

  late final _spine_animation_state_data_get_skeleton_dataPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_data Function(spine_animation_state_data)>>(
          'spine_animation_state_data_get_skeleton_data');
  late final _spine_animation_state_data_get_skeleton_data = _spine_animation_state_data_get_skeleton_dataPtr
      .asFunction<spine_skeleton_data Function(spine_animation_state_data)>();

  /// The mix duration to use when no mix duration has been specifically defined
  /// between two animations.
  double spine_animation_state_data_get_default_mix(
    spine_animation_state_data self,
  ) {
    return _spine_animation_state_data_get_default_mix(
      self,
    );
  }

  late final _spine_animation_state_data_get_default_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_animation_state_data)>>(
          'spine_animation_state_data_get_default_mix');
  late final _spine_animation_state_data_get_default_mix =
      _spine_animation_state_data_get_default_mixPtr.asFunction<double Function(spine_animation_state_data)>();

  void spine_animation_state_data_set_default_mix(
    spine_animation_state_data self,
    double inValue,
  ) {
    return _spine_animation_state_data_set_default_mix(
      self,
      inValue,
    );
  }

  late final _spine_animation_state_data_set_default_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state_data, ffi.Float)>>(
          'spine_animation_state_data_set_default_mix');
  late final _spine_animation_state_data_set_default_mix =
      _spine_animation_state_data_set_default_mixPtr.asFunction<void Function(spine_animation_state_data, double)>();

  /// Sets a mix duration by animation names.
  void spine_animation_state_data_set_mix_1(
    spine_animation_state_data self,
    ffi.Pointer<ffi.Char> fromName,
    ffi.Pointer<ffi.Char> toName,
    double duration,
  ) {
    return _spine_animation_state_data_set_mix_1(
      self,
      fromName,
      toName,
      duration,
    );
  }

  late final _spine_animation_state_data_set_mix_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_animation_state_data, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>,
              ffi.Float)>>('spine_animation_state_data_set_mix_1');
  late final _spine_animation_state_data_set_mix_1 = _spine_animation_state_data_set_mix_1Ptr
      .asFunction<void Function(spine_animation_state_data, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, double)>();

  /// Sets a mix duration when changing from the specified animation to the other.
  /// See TrackEntry.MixDuration.
  void spine_animation_state_data_set_mix_2(
    spine_animation_state_data self,
    spine_animation from,
    spine_animation to,
    double duration,
  ) {
    return _spine_animation_state_data_set_mix_2(
      self,
      from,
      to,
      duration,
    );
  }

  late final _spine_animation_state_data_set_mix_2Ptr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_animation_state_data, spine_animation, spine_animation, ffi.Float)>>(
      'spine_animation_state_data_set_mix_2');
  late final _spine_animation_state_data_set_mix_2 = _spine_animation_state_data_set_mix_2Ptr
      .asFunction<void Function(spine_animation_state_data, spine_animation, spine_animation, double)>();

  /// The mix duration to use when changing from the specified animation to the
  /// other, or the DefaultMix if no mix duration has been set.
  double spine_animation_state_data_get_mix(
    spine_animation_state_data self,
    spine_animation from,
    spine_animation to,
  ) {
    return _spine_animation_state_data_get_mix(
      self,
      from,
      to,
    );
  }

  late final _spine_animation_state_data_get_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_animation_state_data, spine_animation, spine_animation)>>(
          'spine_animation_state_data_get_mix');
  late final _spine_animation_state_data_get_mix = _spine_animation_state_data_get_mixPtr
      .asFunction<double Function(spine_animation_state_data, spine_animation, spine_animation)>();

  /// Removes all mixes and sets the default mix to 0.
  void spine_animation_state_data_clear(
    spine_animation_state_data self,
  ) {
    return _spine_animation_state_data_clear(
      self,
    );
  }

  late final _spine_animation_state_data_clearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state_data)>>('spine_animation_state_data_clear');
  late final _spine_animation_state_data_clear =
      _spine_animation_state_data_clearPtr.asFunction<void Function(spine_animation_state_data)>();

  spine_atlas_attachment_loader spine_atlas_attachment_loader_create(
    spine_atlas atlas,
  ) {
    return _spine_atlas_attachment_loader_create(
      atlas,
    );
  }

  late final _spine_atlas_attachment_loader_createPtr =
      _lookup<ffi.NativeFunction<spine_atlas_attachment_loader Function(spine_atlas)>>(
          'spine_atlas_attachment_loader_create');
  late final _spine_atlas_attachment_loader_create =
      _spine_atlas_attachment_loader_createPtr.asFunction<spine_atlas_attachment_loader Function(spine_atlas)>();

  void spine_atlas_attachment_loader_dispose(
    spine_atlas_attachment_loader self,
  ) {
    return _spine_atlas_attachment_loader_dispose(
      self,
    );
  }

  late final _spine_atlas_attachment_loader_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_attachment_loader)>>(
          'spine_atlas_attachment_loader_dispose');
  late final _spine_atlas_attachment_loader_dispose =
      _spine_atlas_attachment_loader_disposePtr.asFunction<void Function(spine_atlas_attachment_loader)>();

  spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(
    spine_atlas_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
    ffi.Pointer<ffi.Char> path,
    spine_sequence sequence,
  ) {
    return _spine_atlas_attachment_loader_new_region_attachment(
      self,
      skin,
      name,
      path,
      sequence,
    );
  }

  late final _spine_atlas_attachment_loader_new_region_attachmentPtr = _lookup<
      ffi.NativeFunction<
          spine_region_attachment Function(spine_atlas_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, spine_sequence)>>('spine_atlas_attachment_loader_new_region_attachment');
  late final _spine_atlas_attachment_loader_new_region_attachment =
      _spine_atlas_attachment_loader_new_region_attachmentPtr.asFunction<
          spine_region_attachment Function(spine_atlas_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, spine_sequence)>();

  spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(
    spine_atlas_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
    ffi.Pointer<ffi.Char> path,
    spine_sequence sequence,
  ) {
    return _spine_atlas_attachment_loader_new_mesh_attachment(
      self,
      skin,
      name,
      path,
      sequence,
    );
  }

  late final _spine_atlas_attachment_loader_new_mesh_attachmentPtr = _lookup<
      ffi.NativeFunction<
          spine_mesh_attachment Function(spine_atlas_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, spine_sequence)>>('spine_atlas_attachment_loader_new_mesh_attachment');
  late final _spine_atlas_attachment_loader_new_mesh_attachment =
      _spine_atlas_attachment_loader_new_mesh_attachmentPtr.asFunction<
          spine_mesh_attachment Function(spine_atlas_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, spine_sequence)>();

  spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(
    spine_atlas_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_atlas_attachment_loader_new_bounding_box_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_atlas_attachment_loader_new_bounding_box_attachmentPtr = _lookup<
      ffi.NativeFunction<
          spine_bounding_box_attachment Function(spine_atlas_attachment_loader, spine_skin,
              ffi.Pointer<ffi.Char>)>>('spine_atlas_attachment_loader_new_bounding_box_attachment');
  late final _spine_atlas_attachment_loader_new_bounding_box_attachment =
      _spine_atlas_attachment_loader_new_bounding_box_attachmentPtr.asFunction<
          spine_bounding_box_attachment Function(spine_atlas_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(
    spine_atlas_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_atlas_attachment_loader_new_path_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_atlas_attachment_loader_new_path_attachmentPtr = _lookup<
      ffi.NativeFunction<
          spine_path_attachment Function(spine_atlas_attachment_loader, spine_skin,
              ffi.Pointer<ffi.Char>)>>('spine_atlas_attachment_loader_new_path_attachment');
  late final _spine_atlas_attachment_loader_new_path_attachment = _spine_atlas_attachment_loader_new_path_attachmentPtr
      .asFunction<spine_path_attachment Function(spine_atlas_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(
    spine_atlas_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_atlas_attachment_loader_new_point_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_atlas_attachment_loader_new_point_attachmentPtr = _lookup<
      ffi.NativeFunction<
          spine_point_attachment Function(spine_atlas_attachment_loader, spine_skin,
              ffi.Pointer<ffi.Char>)>>('spine_atlas_attachment_loader_new_point_attachment');
  late final _spine_atlas_attachment_loader_new_point_attachment =
      _spine_atlas_attachment_loader_new_point_attachmentPtr.asFunction<
          spine_point_attachment Function(spine_atlas_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(
    spine_atlas_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_atlas_attachment_loader_new_clipping_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_atlas_attachment_loader_new_clipping_attachmentPtr = _lookup<
      ffi.NativeFunction<
          spine_clipping_attachment Function(spine_atlas_attachment_loader, spine_skin,
              ffi.Pointer<ffi.Char>)>>('spine_atlas_attachment_loader_new_clipping_attachment');
  late final _spine_atlas_attachment_loader_new_clipping_attachment =
      _spine_atlas_attachment_loader_new_clipping_attachmentPtr.asFunction<
          spine_clipping_attachment Function(spine_atlas_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_atlas_region spine_atlas_attachment_loader_find_region(
    spine_atlas_attachment_loader self,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_atlas_attachment_loader_find_region(
      self,
      name,
    );
  }

  late final _spine_atlas_attachment_loader_find_regionPtr =
      _lookup<ffi.NativeFunction<spine_atlas_region Function(spine_atlas_attachment_loader, ffi.Pointer<ffi.Char>)>>(
          'spine_atlas_attachment_loader_find_region');
  late final _spine_atlas_attachment_loader_find_region = _spine_atlas_attachment_loader_find_regionPtr
      .asFunction<spine_atlas_region Function(spine_atlas_attachment_loader, ffi.Pointer<ffi.Char>)>();

  spine_atlas_page spine_atlas_page_create(
    ffi.Pointer<ffi.Char> inName,
  ) {
    return _spine_atlas_page_create(
      inName,
    );
  }

  late final _spine_atlas_page_createPtr =
      _lookup<ffi.NativeFunction<spine_atlas_page Function(ffi.Pointer<ffi.Char>)>>('spine_atlas_page_create');
  late final _spine_atlas_page_create =
      _spine_atlas_page_createPtr.asFunction<spine_atlas_page Function(ffi.Pointer<ffi.Char>)>();

  void spine_atlas_page_dispose(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_dispose(
      self,
    );
  }

  late final _spine_atlas_page_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page)>>('spine_atlas_page_dispose');
  late final _spine_atlas_page_dispose = _spine_atlas_page_disposePtr.asFunction<void Function(spine_atlas_page)>();

  ffi.Pointer<ffi.Char> spine_atlas_page_get_name(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_name(
      self,
    );
  }

  late final _spine_atlas_page_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_atlas_page)>>('spine_atlas_page_get_name');
  late final _spine_atlas_page_get_name =
      _spine_atlas_page_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_atlas_page)>();

  void spine_atlas_page_set_name(
    spine_atlas_page self,
    ffi.Pointer<ffi.Char> value,
  ) {
    return _spine_atlas_page_set_name(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_namePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Pointer<ffi.Char>)>>(
          'spine_atlas_page_set_name');
  late final _spine_atlas_page_set_name =
      _spine_atlas_page_set_namePtr.asFunction<void Function(spine_atlas_page, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> spine_atlas_page_get_texture_path(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_texture_path(
      self,
    );
  }

  late final _spine_atlas_page_get_texture_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_atlas_page)>>(
          'spine_atlas_page_get_texture_path');
  late final _spine_atlas_page_get_texture_path =
      _spine_atlas_page_get_texture_pathPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_atlas_page)>();

  void spine_atlas_page_set_texture_path(
    spine_atlas_page self,
    ffi.Pointer<ffi.Char> value,
  ) {
    return _spine_atlas_page_set_texture_path(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_texture_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Pointer<ffi.Char>)>>(
          'spine_atlas_page_set_texture_path');
  late final _spine_atlas_page_set_texture_path =
      _spine_atlas_page_set_texture_pathPtr.asFunction<void Function(spine_atlas_page, ffi.Pointer<ffi.Char>)>();

  int spine_atlas_page_get_format(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_format(
      self,
    );
  }

  late final _spine_atlas_page_get_formatPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_atlas_page)>>('spine_atlas_page_get_format');
  late final _spine_atlas_page_get_format =
      _spine_atlas_page_get_formatPtr.asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_format(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_format(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_formatPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int32)>>('spine_atlas_page_set_format');
  late final _spine_atlas_page_set_format =
      _spine_atlas_page_set_formatPtr.asFunction<void Function(spine_atlas_page, int)>();

  int spine_atlas_page_get_min_filter(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_min_filter(
      self,
    );
  }

  late final _spine_atlas_page_get_min_filterPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_atlas_page)>>('spine_atlas_page_get_min_filter');
  late final _spine_atlas_page_get_min_filter =
      _spine_atlas_page_get_min_filterPtr.asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_min_filter(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_min_filter(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_min_filterPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int32)>>('spine_atlas_page_set_min_filter');
  late final _spine_atlas_page_set_min_filter =
      _spine_atlas_page_set_min_filterPtr.asFunction<void Function(spine_atlas_page, int)>();

  int spine_atlas_page_get_mag_filter(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_mag_filter(
      self,
    );
  }

  late final _spine_atlas_page_get_mag_filterPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_atlas_page)>>('spine_atlas_page_get_mag_filter');
  late final _spine_atlas_page_get_mag_filter =
      _spine_atlas_page_get_mag_filterPtr.asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_mag_filter(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_mag_filter(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_mag_filterPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int32)>>('spine_atlas_page_set_mag_filter');
  late final _spine_atlas_page_set_mag_filter =
      _spine_atlas_page_set_mag_filterPtr.asFunction<void Function(spine_atlas_page, int)>();

  int spine_atlas_page_get_u_wrap(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_u_wrap(
      self,
    );
  }

  late final _spine_atlas_page_get_u_wrapPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_atlas_page)>>('spine_atlas_page_get_u_wrap');
  late final _spine_atlas_page_get_u_wrap =
      _spine_atlas_page_get_u_wrapPtr.asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_u_wrap(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_u_wrap(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_u_wrapPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int32)>>('spine_atlas_page_set_u_wrap');
  late final _spine_atlas_page_set_u_wrap =
      _spine_atlas_page_set_u_wrapPtr.asFunction<void Function(spine_atlas_page, int)>();

  int spine_atlas_page_get_v_wrap(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_v_wrap(
      self,
    );
  }

  late final _spine_atlas_page_get_v_wrapPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_atlas_page)>>('spine_atlas_page_get_v_wrap');
  late final _spine_atlas_page_get_v_wrap =
      _spine_atlas_page_get_v_wrapPtr.asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_v_wrap(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_v_wrap(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_v_wrapPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int32)>>('spine_atlas_page_set_v_wrap');
  late final _spine_atlas_page_set_v_wrap =
      _spine_atlas_page_set_v_wrapPtr.asFunction<void Function(spine_atlas_page, int)>();

  int spine_atlas_page_get_width(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_width(
      self,
    );
  }

  late final _spine_atlas_page_get_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_page)>>('spine_atlas_page_get_width');
  late final _spine_atlas_page_get_width = _spine_atlas_page_get_widthPtr.asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_width(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_width(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int)>>('spine_atlas_page_set_width');
  late final _spine_atlas_page_set_width =
      _spine_atlas_page_set_widthPtr.asFunction<void Function(spine_atlas_page, int)>();

  int spine_atlas_page_get_height(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_height(
      self,
    );
  }

  late final _spine_atlas_page_get_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_page)>>('spine_atlas_page_get_height');
  late final _spine_atlas_page_get_height =
      _spine_atlas_page_get_heightPtr.asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_height(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_height(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int)>>('spine_atlas_page_set_height');
  late final _spine_atlas_page_set_height =
      _spine_atlas_page_set_heightPtr.asFunction<void Function(spine_atlas_page, int)>();

  bool spine_atlas_page_get_pma(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_pma(
      self,
    );
  }

  late final _spine_atlas_page_get_pmaPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_atlas_page)>>('spine_atlas_page_get_pma');
  late final _spine_atlas_page_get_pma = _spine_atlas_page_get_pmaPtr.asFunction<bool Function(spine_atlas_page)>();

  void spine_atlas_page_set_pma(
    spine_atlas_page self,
    bool value,
  ) {
    return _spine_atlas_page_set_pma(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_pmaPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Bool)>>('spine_atlas_page_set_pma');
  late final _spine_atlas_page_set_pma =
      _spine_atlas_page_set_pmaPtr.asFunction<void Function(spine_atlas_page, bool)>();

  int spine_atlas_page_get_index(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_index(
      self,
    );
  }

  late final _spine_atlas_page_get_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_page)>>('spine_atlas_page_get_index');
  late final _spine_atlas_page_get_index = _spine_atlas_page_get_indexPtr.asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_index(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_index(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int)>>('spine_atlas_page_set_index');
  late final _spine_atlas_page_set_index =
      _spine_atlas_page_set_indexPtr.asFunction<void Function(spine_atlas_page, int)>();

  ffi.Pointer<ffi.Void> spine_atlas_page_get_texture(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_texture(
      self,
    );
  }

  late final _spine_atlas_page_get_texturePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(spine_atlas_page)>>('spine_atlas_page_get_texture');
  late final _spine_atlas_page_get_texture =
      _spine_atlas_page_get_texturePtr.asFunction<ffi.Pointer<ffi.Void> Function(spine_atlas_page)>();

  void spine_atlas_page_set_texture(
    spine_atlas_page self,
    ffi.Pointer<ffi.Void> value,
  ) {
    return _spine_atlas_page_set_texture(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_texturePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Pointer<ffi.Void>)>>(
          'spine_atlas_page_set_texture');
  late final _spine_atlas_page_set_texture =
      _spine_atlas_page_set_texturePtr.asFunction<void Function(spine_atlas_page, ffi.Pointer<ffi.Void>)>();

  spine_atlas_region spine_atlas_region_create() {
    return _spine_atlas_region_create();
  }

  late final _spine_atlas_region_createPtr =
      _lookup<ffi.NativeFunction<spine_atlas_region Function()>>('spine_atlas_region_create');
  late final _spine_atlas_region_create = _spine_atlas_region_createPtr.asFunction<spine_atlas_region Function()>();

  void spine_atlas_region_dispose(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_dispose(
      self,
    );
  }

  late final _spine_atlas_region_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region)>>('spine_atlas_region_dispose');
  late final _spine_atlas_region_dispose =
      _spine_atlas_region_disposePtr.asFunction<void Function(spine_atlas_region)>();

  spine_rtti spine_atlas_region_get_rtti(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_rtti(
      self,
    );
  }

  late final _spine_atlas_region_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_atlas_region)>>('spine_atlas_region_get_rtti');
  late final _spine_atlas_region_get_rtti =
      _spine_atlas_region_get_rttiPtr.asFunction<spine_rtti Function(spine_atlas_region)>();

  spine_atlas_page spine_atlas_region_get_page(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_page(
      self,
    );
  }

  late final _spine_atlas_region_get_pagePtr =
      _lookup<ffi.NativeFunction<spine_atlas_page Function(spine_atlas_region)>>('spine_atlas_region_get_page');
  late final _spine_atlas_region_get_page =
      _spine_atlas_region_get_pagePtr.asFunction<spine_atlas_page Function(spine_atlas_region)>();

  ffi.Pointer<ffi.Char> spine_atlas_region_get_name(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_name(
      self,
    );
  }

  late final _spine_atlas_region_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_atlas_region)>>('spine_atlas_region_get_name');
  late final _spine_atlas_region_get_name =
      _spine_atlas_region_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_atlas_region)>();

  int spine_atlas_region_get_index(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_index(
      self,
    );
  }

  late final _spine_atlas_region_get_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>('spine_atlas_region_get_index');
  late final _spine_atlas_region_get_index =
      _spine_atlas_region_get_indexPtr.asFunction<int Function(spine_atlas_region)>();

  int spine_atlas_region_get_x(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_x(
      self,
    );
  }

  late final _spine_atlas_region_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>('spine_atlas_region_get_x');
  late final _spine_atlas_region_get_x = _spine_atlas_region_get_xPtr.asFunction<int Function(spine_atlas_region)>();

  int spine_atlas_region_get_y(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_y(
      self,
    );
  }

  late final _spine_atlas_region_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>('spine_atlas_region_get_y');
  late final _spine_atlas_region_get_y = _spine_atlas_region_get_yPtr.asFunction<int Function(spine_atlas_region)>();

  double spine_atlas_region_get_offset_x(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_offset_x(
      self,
    );
  }

  late final _spine_atlas_region_get_offset_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_atlas_region)>>('spine_atlas_region_get_offset_x');
  late final _spine_atlas_region_get_offset_x =
      _spine_atlas_region_get_offset_xPtr.asFunction<double Function(spine_atlas_region)>();

  double spine_atlas_region_get_offset_y(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_offset_y(
      self,
    );
  }

  late final _spine_atlas_region_get_offset_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_atlas_region)>>('spine_atlas_region_get_offset_y');
  late final _spine_atlas_region_get_offset_y =
      _spine_atlas_region_get_offset_yPtr.asFunction<double Function(spine_atlas_region)>();

  int spine_atlas_region_get_packed_width(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_packed_width(
      self,
    );
  }

  late final _spine_atlas_region_get_packed_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>('spine_atlas_region_get_packed_width');
  late final _spine_atlas_region_get_packed_width =
      _spine_atlas_region_get_packed_widthPtr.asFunction<int Function(spine_atlas_region)>();

  int spine_atlas_region_get_packed_height(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_packed_height(
      self,
    );
  }

  late final _spine_atlas_region_get_packed_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>('spine_atlas_region_get_packed_height');
  late final _spine_atlas_region_get_packed_height =
      _spine_atlas_region_get_packed_heightPtr.asFunction<int Function(spine_atlas_region)>();

  int spine_atlas_region_get_original_width(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_original_width(
      self,
    );
  }

  late final _spine_atlas_region_get_original_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>('spine_atlas_region_get_original_width');
  late final _spine_atlas_region_get_original_width =
      _spine_atlas_region_get_original_widthPtr.asFunction<int Function(spine_atlas_region)>();

  int spine_atlas_region_get_original_height(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_original_height(
      self,
    );
  }

  late final _spine_atlas_region_get_original_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>('spine_atlas_region_get_original_height');
  late final _spine_atlas_region_get_original_height =
      _spine_atlas_region_get_original_heightPtr.asFunction<int Function(spine_atlas_region)>();

  bool spine_atlas_region_get_rotate(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_rotate(
      self,
    );
  }

  late final _spine_atlas_region_get_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_atlas_region)>>('spine_atlas_region_get_rotate');
  late final _spine_atlas_region_get_rotate =
      _spine_atlas_region_get_rotatePtr.asFunction<bool Function(spine_atlas_region)>();

  int spine_atlas_region_get_degrees(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_degrees(
      self,
    );
  }

  late final _spine_atlas_region_get_degreesPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>('spine_atlas_region_get_degrees');
  late final _spine_atlas_region_get_degrees =
      _spine_atlas_region_get_degreesPtr.asFunction<int Function(spine_atlas_region)>();

  spine_array_int spine_atlas_region_get_splits(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_splits(
      self,
    );
  }

  late final _spine_atlas_region_get_splitsPtr =
      _lookup<ffi.NativeFunction<spine_array_int Function(spine_atlas_region)>>('spine_atlas_region_get_splits');
  late final _spine_atlas_region_get_splits =
      _spine_atlas_region_get_splitsPtr.asFunction<spine_array_int Function(spine_atlas_region)>();

  spine_array_int spine_atlas_region_get_pads(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_pads(
      self,
    );
  }

  late final _spine_atlas_region_get_padsPtr =
      _lookup<ffi.NativeFunction<spine_array_int Function(spine_atlas_region)>>('spine_atlas_region_get_pads');
  late final _spine_atlas_region_get_pads =
      _spine_atlas_region_get_padsPtr.asFunction<spine_array_int Function(spine_atlas_region)>();

  spine_array_float spine_atlas_region_get_values(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_values(
      self,
    );
  }

  late final _spine_atlas_region_get_valuesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_atlas_region)>>('spine_atlas_region_get_values');
  late final _spine_atlas_region_get_values =
      _spine_atlas_region_get_valuesPtr.asFunction<spine_array_float Function(spine_atlas_region)>();

  void spine_atlas_region_set_page(
    spine_atlas_region self,
    spine_atlas_page value,
  ) {
    return _spine_atlas_region_set_page(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_pagePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, spine_atlas_page)>>(
          'spine_atlas_region_set_page');
  late final _spine_atlas_region_set_page =
      _spine_atlas_region_set_pagePtr.asFunction<void Function(spine_atlas_region, spine_atlas_page)>();

  void spine_atlas_region_set_name(
    spine_atlas_region self,
    ffi.Pointer<ffi.Char> value,
  ) {
    return _spine_atlas_region_set_name(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_namePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Pointer<ffi.Char>)>>(
          'spine_atlas_region_set_name');
  late final _spine_atlas_region_set_name =
      _spine_atlas_region_set_namePtr.asFunction<void Function(spine_atlas_region, ffi.Pointer<ffi.Char>)>();

  void spine_atlas_region_set_index(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_index(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>('spine_atlas_region_set_index');
  late final _spine_atlas_region_set_index =
      _spine_atlas_region_set_indexPtr.asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_x(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_x(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>('spine_atlas_region_set_x');
  late final _spine_atlas_region_set_x =
      _spine_atlas_region_set_xPtr.asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_y(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_y(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>('spine_atlas_region_set_y');
  late final _spine_atlas_region_set_y =
      _spine_atlas_region_set_yPtr.asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_offset_x(
    spine_atlas_region self,
    double value,
  ) {
    return _spine_atlas_region_set_offset_x(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_offset_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Float)>>('spine_atlas_region_set_offset_x');
  late final _spine_atlas_region_set_offset_x =
      _spine_atlas_region_set_offset_xPtr.asFunction<void Function(spine_atlas_region, double)>();

  void spine_atlas_region_set_offset_y(
    spine_atlas_region self,
    double value,
  ) {
    return _spine_atlas_region_set_offset_y(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_offset_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Float)>>('spine_atlas_region_set_offset_y');
  late final _spine_atlas_region_set_offset_y =
      _spine_atlas_region_set_offset_yPtr.asFunction<void Function(spine_atlas_region, double)>();

  void spine_atlas_region_set_packed_width(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_packed_width(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_packed_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
          'spine_atlas_region_set_packed_width');
  late final _spine_atlas_region_set_packed_width =
      _spine_atlas_region_set_packed_widthPtr.asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_packed_height(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_packed_height(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_packed_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
          'spine_atlas_region_set_packed_height');
  late final _spine_atlas_region_set_packed_height =
      _spine_atlas_region_set_packed_heightPtr.asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_original_width(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_original_width(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_original_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
          'spine_atlas_region_set_original_width');
  late final _spine_atlas_region_set_original_width =
      _spine_atlas_region_set_original_widthPtr.asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_original_height(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_original_height(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_original_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
          'spine_atlas_region_set_original_height');
  late final _spine_atlas_region_set_original_height =
      _spine_atlas_region_set_original_heightPtr.asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_rotate(
    spine_atlas_region self,
    bool value,
  ) {
    return _spine_atlas_region_set_rotate(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Bool)>>('spine_atlas_region_set_rotate');
  late final _spine_atlas_region_set_rotate =
      _spine_atlas_region_set_rotatePtr.asFunction<void Function(spine_atlas_region, bool)>();

  void spine_atlas_region_set_degrees(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_degrees(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_degreesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>('spine_atlas_region_set_degrees');
  late final _spine_atlas_region_set_degrees =
      _spine_atlas_region_set_degreesPtr.asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_splits(
    spine_atlas_region self,
    spine_array_int value,
  ) {
    return _spine_atlas_region_set_splits(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_splitsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, spine_array_int)>>(
          'spine_atlas_region_set_splits');
  late final _spine_atlas_region_set_splits =
      _spine_atlas_region_set_splitsPtr.asFunction<void Function(spine_atlas_region, spine_array_int)>();

  void spine_atlas_region_set_pads(
    spine_atlas_region self,
    spine_array_int value,
  ) {
    return _spine_atlas_region_set_pads(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_padsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, spine_array_int)>>(
          'spine_atlas_region_set_pads');
  late final _spine_atlas_region_set_pads =
      _spine_atlas_region_set_padsPtr.asFunction<void Function(spine_atlas_region, spine_array_int)>();

  void spine_atlas_region_set_values(
    spine_atlas_region self,
    spine_array_float value,
  ) {
    return _spine_atlas_region_set_values(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_valuesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, spine_array_float)>>(
          'spine_atlas_region_set_values');
  late final _spine_atlas_region_set_values =
      _spine_atlas_region_set_valuesPtr.asFunction<void Function(spine_atlas_region, spine_array_float)>();

  double spine_atlas_region_get_u(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_u(
      self,
    );
  }

  late final _spine_atlas_region_get_uPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_atlas_region)>>('spine_atlas_region_get_u');
  late final _spine_atlas_region_get_u = _spine_atlas_region_get_uPtr.asFunction<double Function(spine_atlas_region)>();

  void spine_atlas_region_set_u(
    spine_atlas_region self,
    double value,
  ) {
    return _spine_atlas_region_set_u(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_uPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Float)>>('spine_atlas_region_set_u');
  late final _spine_atlas_region_set_u =
      _spine_atlas_region_set_uPtr.asFunction<void Function(spine_atlas_region, double)>();

  double spine_atlas_region_get_v(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_v(
      self,
    );
  }

  late final _spine_atlas_region_get_vPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_atlas_region)>>('spine_atlas_region_get_v');
  late final _spine_atlas_region_get_v = _spine_atlas_region_get_vPtr.asFunction<double Function(spine_atlas_region)>();

  void spine_atlas_region_set_v(
    spine_atlas_region self,
    double value,
  ) {
    return _spine_atlas_region_set_v(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_vPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Float)>>('spine_atlas_region_set_v');
  late final _spine_atlas_region_set_v =
      _spine_atlas_region_set_vPtr.asFunction<void Function(spine_atlas_region, double)>();

  double spine_atlas_region_get_u2(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_u2(
      self,
    );
  }

  late final _spine_atlas_region_get_u2Ptr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_atlas_region)>>('spine_atlas_region_get_u2');
  late final _spine_atlas_region_get_u2 =
      _spine_atlas_region_get_u2Ptr.asFunction<double Function(spine_atlas_region)>();

  void spine_atlas_region_set_u2(
    spine_atlas_region self,
    double value,
  ) {
    return _spine_atlas_region_set_u2(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_u2Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Float)>>('spine_atlas_region_set_u2');
  late final _spine_atlas_region_set_u2 =
      _spine_atlas_region_set_u2Ptr.asFunction<void Function(spine_atlas_region, double)>();

  double spine_atlas_region_get_v2(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_v2(
      self,
    );
  }

  late final _spine_atlas_region_get_v2Ptr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_atlas_region)>>('spine_atlas_region_get_v2');
  late final _spine_atlas_region_get_v2 =
      _spine_atlas_region_get_v2Ptr.asFunction<double Function(spine_atlas_region)>();

  void spine_atlas_region_set_v2(
    spine_atlas_region self,
    double value,
  ) {
    return _spine_atlas_region_set_v2(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_v2Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Float)>>('spine_atlas_region_set_v2');
  late final _spine_atlas_region_set_v2 =
      _spine_atlas_region_set_v2Ptr.asFunction<void Function(spine_atlas_region, double)>();

  int spine_atlas_region_get_region_width(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_region_width(
      self,
    );
  }

  late final _spine_atlas_region_get_region_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>('spine_atlas_region_get_region_width');
  late final _spine_atlas_region_get_region_width =
      _spine_atlas_region_get_region_widthPtr.asFunction<int Function(spine_atlas_region)>();

  void spine_atlas_region_set_region_width(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_region_width(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_region_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
          'spine_atlas_region_set_region_width');
  late final _spine_atlas_region_set_region_width =
      _spine_atlas_region_set_region_widthPtr.asFunction<void Function(spine_atlas_region, int)>();

  int spine_atlas_region_get_region_height(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_region_height(
      self,
    );
  }

  late final _spine_atlas_region_get_region_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>('spine_atlas_region_get_region_height');
  late final _spine_atlas_region_get_region_height =
      _spine_atlas_region_get_region_heightPtr.asFunction<int Function(spine_atlas_region)>();

  void spine_atlas_region_set_region_height(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_region_height(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_region_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
          'spine_atlas_region_set_region_height');
  late final _spine_atlas_region_set_region_height =
      _spine_atlas_region_set_region_heightPtr.asFunction<void Function(spine_atlas_region, int)>();

  ffi.Pointer<ffi.Void> spine_atlas_region_get_renderer_object(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_renderer_object(
      self,
    );
  }

  late final _spine_atlas_region_get_renderer_objectPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(spine_atlas_region)>>(
          'spine_atlas_region_get_renderer_object');
  late final _spine_atlas_region_get_renderer_object =
      _spine_atlas_region_get_renderer_objectPtr.asFunction<ffi.Pointer<ffi.Void> Function(spine_atlas_region)>();

  void spine_atlas_region_set_renderer_object(
    spine_atlas_region self,
    ffi.Pointer<ffi.Void> value,
  ) {
    return _spine_atlas_region_set_renderer_object(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_renderer_objectPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Pointer<ffi.Void>)>>(
          'spine_atlas_region_set_renderer_object');
  late final _spine_atlas_region_set_renderer_object =
      _spine_atlas_region_set_renderer_objectPtr.asFunction<void Function(spine_atlas_region, ffi.Pointer<ffi.Void>)>();

  spine_rtti spine_atlas_region_rtti() {
    return _spine_atlas_region_rtti();
  }

  late final _spine_atlas_region_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_atlas_region_rtti');
  late final _spine_atlas_region_rtti = _spine_atlas_region_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_attachment_dispose(
    spine_attachment self,
  ) {
    return _spine_attachment_dispose(
      self,
    );
  }

  late final _spine_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_attachment)>>('spine_attachment_dispose');
  late final _spine_attachment_dispose = _spine_attachment_disposePtr.asFunction<void Function(spine_attachment)>();

  spine_rtti spine_attachment_get_rtti(
    spine_attachment self,
  ) {
    return _spine_attachment_get_rtti(
      self,
    );
  }

  late final _spine_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_attachment)>>('spine_attachment_get_rtti');
  late final _spine_attachment_get_rtti =
      _spine_attachment_get_rttiPtr.asFunction<spine_rtti Function(spine_attachment)>();

  ffi.Pointer<ffi.Char> spine_attachment_get_name(
    spine_attachment self,
  ) {
    return _spine_attachment_get_name(
      self,
    );
  }

  late final _spine_attachment_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_attachment)>>('spine_attachment_get_name');
  late final _spine_attachment_get_name =
      _spine_attachment_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_attachment)>();

  spine_attachment spine_attachment_copy(
    spine_attachment self,
  ) {
    return _spine_attachment_copy(
      self,
    );
  }

  late final _spine_attachment_copyPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_attachment)>>('spine_attachment_copy');
  late final _spine_attachment_copy =
      _spine_attachment_copyPtr.asFunction<spine_attachment Function(spine_attachment)>();

  int spine_attachment_get_ref_count(
    spine_attachment self,
  ) {
    return _spine_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_attachment)>>('spine_attachment_get_ref_count');
  late final _spine_attachment_get_ref_count =
      _spine_attachment_get_ref_countPtr.asFunction<int Function(spine_attachment)>();

  void spine_attachment_reference(
    spine_attachment self,
  ) {
    return _spine_attachment_reference(
      self,
    );
  }

  late final _spine_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_attachment)>>('spine_attachment_reference');
  late final _spine_attachment_reference = _spine_attachment_referencePtr.asFunction<void Function(spine_attachment)>();

  void spine_attachment_dereference(
    spine_attachment self,
  ) {
    return _spine_attachment_dereference(
      self,
    );
  }

  late final _spine_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_attachment)>>('spine_attachment_dereference');
  late final _spine_attachment_dereference =
      _spine_attachment_dereferencePtr.asFunction<void Function(spine_attachment)>();

  spine_rtti spine_attachment_rtti() {
    return _spine_attachment_rtti();
  }

  late final _spine_attachment_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_attachment_rtti');
  late final _spine_attachment_rtti = _spine_attachment_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_attachment_loader_dispose(
    spine_attachment_loader self,
  ) {
    return _spine_attachment_loader_dispose(
      self,
    );
  }

  late final _spine_attachment_loader_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_attachment_loader)>>('spine_attachment_loader_dispose');
  late final _spine_attachment_loader_dispose =
      _spine_attachment_loader_disposePtr.asFunction<void Function(spine_attachment_loader)>();

  spine_region_attachment spine_attachment_loader_new_region_attachment(
    spine_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
    ffi.Pointer<ffi.Char> path,
    spine_sequence sequence,
  ) {
    return _spine_attachment_loader_new_region_attachment(
      self,
      skin,
      name,
      path,
      sequence,
    );
  }

  late final _spine_attachment_loader_new_region_attachmentPtr = _lookup<
      ffi.NativeFunction<
          spine_region_attachment Function(spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, spine_sequence)>>('spine_attachment_loader_new_region_attachment');
  late final _spine_attachment_loader_new_region_attachment =
      _spine_attachment_loader_new_region_attachmentPtr.asFunction<
          spine_region_attachment Function(
              spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, spine_sequence)>();

  spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(
    spine_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
    ffi.Pointer<ffi.Char> path,
    spine_sequence sequence,
  ) {
    return _spine_attachment_loader_new_mesh_attachment(
      self,
      skin,
      name,
      path,
      sequence,
    );
  }

  late final _spine_attachment_loader_new_mesh_attachmentPtr = _lookup<
      ffi.NativeFunction<
          spine_mesh_attachment Function(spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, spine_sequence)>>('spine_attachment_loader_new_mesh_attachment');
  late final _spine_attachment_loader_new_mesh_attachment = _spine_attachment_loader_new_mesh_attachmentPtr.asFunction<
      spine_mesh_attachment Function(
          spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, spine_sequence)>();

  spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(
    spine_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_attachment_loader_new_bounding_box_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_attachment_loader_new_bounding_box_attachmentPtr = _lookup<
      ffi.NativeFunction<
          spine_bounding_box_attachment Function(spine_attachment_loader, spine_skin,
              ffi.Pointer<ffi.Char>)>>('spine_attachment_loader_new_bounding_box_attachment');
  late final _spine_attachment_loader_new_bounding_box_attachment =
      _spine_attachment_loader_new_bounding_box_attachmentPtr.asFunction<
          spine_bounding_box_attachment Function(spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_path_attachment spine_attachment_loader_new_path_attachment(
    spine_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_attachment_loader_new_path_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_attachment_loader_new_path_attachmentPtr = _lookup<
          ffi
          .NativeFunction<spine_path_attachment Function(spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>>(
      'spine_attachment_loader_new_path_attachment');
  late final _spine_attachment_loader_new_path_attachment = _spine_attachment_loader_new_path_attachmentPtr
      .asFunction<spine_path_attachment Function(spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_point_attachment spine_attachment_loader_new_point_attachment(
    spine_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_attachment_loader_new_point_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_attachment_loader_new_point_attachmentPtr = _lookup<
          ffi
          .NativeFunction<spine_point_attachment Function(spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>>(
      'spine_attachment_loader_new_point_attachment');
  late final _spine_attachment_loader_new_point_attachment = _spine_attachment_loader_new_point_attachmentPtr
      .asFunction<spine_point_attachment Function(spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(
    spine_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_attachment_loader_new_clipping_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_attachment_loader_new_clipping_attachmentPtr = _lookup<
      ffi.NativeFunction<
          spine_clipping_attachment Function(spine_attachment_loader, spine_skin,
              ffi.Pointer<ffi.Char>)>>('spine_attachment_loader_new_clipping_attachment');
  late final _spine_attachment_loader_new_clipping_attachment = _spine_attachment_loader_new_clipping_attachmentPtr
      .asFunction<spine_clipping_attachment Function(spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_attachment_timeline spine_attachment_timeline_create(
    int frameCount,
    int slotIndex,
  ) {
    return _spine_attachment_timeline_create(
      frameCount,
      slotIndex,
    );
  }

  late final _spine_attachment_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_attachment_timeline Function(ffi.Size, ffi.Int)>>(
          'spine_attachment_timeline_create');
  late final _spine_attachment_timeline_create =
      _spine_attachment_timeline_createPtr.asFunction<spine_attachment_timeline Function(int, int)>();

  void spine_attachment_timeline_dispose(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_dispose(
      self,
    );
  }

  late final _spine_attachment_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_attachment_timeline)>>('spine_attachment_timeline_dispose');
  late final _spine_attachment_timeline_dispose =
      _spine_attachment_timeline_disposePtr.asFunction<void Function(spine_attachment_timeline)>();

  spine_rtti spine_attachment_timeline_get_rtti(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_rtti(
      self,
    );
  }

  late final _spine_attachment_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_attachment_timeline)>>('spine_attachment_timeline_get_rtti');
  late final _spine_attachment_timeline_get_rtti =
      _spine_attachment_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_attachment_timeline)>();

  void spine_attachment_timeline_apply(
    spine_attachment_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_attachment_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_attachment_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_attachment_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event,
              ffi.Float, ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_attachment_timeline_apply');
  late final _spine_attachment_timeline_apply = _spine_attachment_timeline_applyPtr.asFunction<
      void Function(
          spine_attachment_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  /// Sets the time and attachment name for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_attachment_timeline_set_frame(
    spine_attachment_timeline self,
    int frame,
    double time,
    ffi.Pointer<ffi.Char> attachmentName,
  ) {
    return _spine_attachment_timeline_set_frame(
      self,
      frame,
      time,
      attachmentName,
    );
  }

  late final _spine_attachment_timeline_set_framePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_attachment_timeline, ffi.Int, ffi.Float, ffi.Pointer<ffi.Char>)>>(
      'spine_attachment_timeline_set_frame');
  late final _spine_attachment_timeline_set_frame = _spine_attachment_timeline_set_framePtr
      .asFunction<void Function(spine_attachment_timeline, int, double, ffi.Pointer<ffi.Char>)>();

  int spine_attachment_timeline_get_slot_index(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_attachment_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_attachment_timeline)>>(
          'spine_attachment_timeline_get_slot_index');
  late final _spine_attachment_timeline_get_slot_index =
      _spine_attachment_timeline_get_slot_indexPtr.asFunction<int Function(spine_attachment_timeline)>();

  void spine_attachment_timeline_set_slot_index(
    spine_attachment_timeline self,
    int inValue,
  ) {
    return _spine_attachment_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_attachment_timeline_set_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_attachment_timeline, ffi.Int)>>(
          'spine_attachment_timeline_set_slot_index');
  late final _spine_attachment_timeline_set_slot_index =
      _spine_attachment_timeline_set_slot_indexPtr.asFunction<void Function(spine_attachment_timeline, int)>();

  int spine_attachment_timeline_get_frame_entries(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_attachment_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_attachment_timeline)>>(
          'spine_attachment_timeline_get_frame_entries');
  late final _spine_attachment_timeline_get_frame_entries =
      _spine_attachment_timeline_get_frame_entriesPtr.asFunction<int Function(spine_attachment_timeline)>();

  int spine_attachment_timeline_get_frame_count(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_attachment_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_attachment_timeline)>>(
          'spine_attachment_timeline_get_frame_count');
  late final _spine_attachment_timeline_get_frame_count =
      _spine_attachment_timeline_get_frame_countPtr.asFunction<int Function(spine_attachment_timeline)>();

  spine_array_float spine_attachment_timeline_get_frames(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_frames(
      self,
    );
  }

  late final _spine_attachment_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_attachment_timeline)>>(
          'spine_attachment_timeline_get_frames');
  late final _spine_attachment_timeline_get_frames =
      _spine_attachment_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_attachment_timeline)>();

  double spine_attachment_timeline_get_duration(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_duration(
      self,
    );
  }

  late final _spine_attachment_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_attachment_timeline)>>(
          'spine_attachment_timeline_get_duration');
  late final _spine_attachment_timeline_get_duration =
      _spine_attachment_timeline_get_durationPtr.asFunction<double Function(spine_attachment_timeline)>();

  spine_array_property_id spine_attachment_timeline_get_property_ids(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_attachment_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_attachment_timeline)>>(
          'spine_attachment_timeline_get_property_ids');
  late final _spine_attachment_timeline_get_property_ids = _spine_attachment_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_attachment_timeline)>();

  spine_rtti spine_attachment_timeline_rtti() {
    return _spine_attachment_timeline_rtti();
  }

  late final _spine_attachment_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_attachment_timeline_rtti');
  late final _spine_attachment_timeline_rtti = _spine_attachment_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  /// @param parent May be NULL.
  spine_bone spine_bone_create(
    spine_bone_data data,
    spine_bone parent,
  ) {
    return _spine_bone_create(
      data,
      parent,
    );
  }

  late final _spine_bone_createPtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_bone_data, spine_bone)>>('spine_bone_create');
  late final _spine_bone_create = _spine_bone_createPtr.asFunction<spine_bone Function(spine_bone_data, spine_bone)>();

  /// Copy constructor. Does not copy the children bones.
  spine_bone spine_bone_create2(
    spine_bone bone,
    spine_bone parent,
  ) {
    return _spine_bone_create2(
      bone,
      parent,
    );
  }

  late final _spine_bone_create2Ptr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_bone, spine_bone)>>('spine_bone_create2');
  late final _spine_bone_create2 = _spine_bone_create2Ptr.asFunction<spine_bone Function(spine_bone, spine_bone)>();

  void spine_bone_dispose(
    spine_bone self,
  ) {
    return _spine_bone_dispose(
      self,
    );
  }

  late final _spine_bone_disposePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>('spine_bone_dispose');
  late final _spine_bone_dispose = _spine_bone_disposePtr.asFunction<void Function(spine_bone)>();

  spine_rtti spine_bone_get_rtti(
    spine_bone self,
  ) {
    return _spine_bone_get_rtti(
      self,
    );
  }

  late final _spine_bone_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_bone)>>('spine_bone_get_rtti');
  late final _spine_bone_get_rtti = _spine_bone_get_rttiPtr.asFunction<spine_rtti Function(spine_bone)>();

  spine_bone spine_bone_get_parent(
    spine_bone self,
  ) {
    return _spine_bone_get_parent(
      self,
    );
  }

  late final _spine_bone_get_parentPtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_bone)>>('spine_bone_get_parent');
  late final _spine_bone_get_parent = _spine_bone_get_parentPtr.asFunction<spine_bone Function(spine_bone)>();

  /// The immediate children of this bone.
  spine_array_bone spine_bone_get_children(
    spine_bone self,
  ) {
    return _spine_bone_get_children(
      self,
    );
  }

  late final _spine_bone_get_childrenPtr =
      _lookup<ffi.NativeFunction<spine_array_bone Function(spine_bone)>>('spine_bone_get_children');
  late final _spine_bone_get_children = _spine_bone_get_childrenPtr.asFunction<spine_array_bone Function(spine_bone)>();

  bool spine_bone_is_y_down() {
    return _spine_bone_is_y_down();
  }

  late final _spine_bone_is_y_downPtr = _lookup<ffi.NativeFunction<ffi.Bool Function()>>('spine_bone_is_y_down');
  late final _spine_bone_is_y_down = _spine_bone_is_y_downPtr.asFunction<bool Function()>();

  void spine_bone_set_y_down(
    bool value,
  ) {
    return _spine_bone_set_y_down(
      value,
    );
  }

  late final _spine_bone_set_y_downPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Bool)>>('spine_bone_set_y_down');
  late final _spine_bone_set_y_down = _spine_bone_set_y_downPtr.asFunction<void Function(bool)>();

  void spine_bone_update(
    spine_bone self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_bone_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_bone_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, spine_skeleton, ffi.Int32)>>('spine_bone_update');
  late final _spine_bone_update = _spine_bone_updatePtr.asFunction<void Function(spine_bone, spine_skeleton, int)>();

  /// The constraint's setup pose data.
  spine_bone_data spine_bone_get_data(
    spine_bone self,
  ) {
    return _spine_bone_get_data(
      self,
    );
  }

  late final _spine_bone_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_bone)>>('spine_bone_get_data');
  late final _spine_bone_get_data = _spine_bone_get_dataPtr.asFunction<spine_bone_data Function(spine_bone)>();

  spine_bone_local spine_bone_get_pose(
    spine_bone self,
  ) {
    return _spine_bone_get_pose(
      self,
    );
  }

  late final _spine_bone_get_posePtr =
      _lookup<ffi.NativeFunction<spine_bone_local Function(spine_bone)>>('spine_bone_get_pose');
  late final _spine_bone_get_pose = _spine_bone_get_posePtr.asFunction<spine_bone_local Function(spine_bone)>();

  spine_bone_pose spine_bone_get_applied_pose(
    spine_bone self,
  ) {
    return _spine_bone_get_applied_pose(
      self,
    );
  }

  late final _spine_bone_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_bone_pose Function(spine_bone)>>('spine_bone_get_applied_pose');
  late final _spine_bone_get_applied_pose =
      _spine_bone_get_applied_posePtr.asFunction<spine_bone_pose Function(spine_bone)>();

  void spine_bone_reset_constrained(
    spine_bone self,
  ) {
    return _spine_bone_reset_constrained(
      self,
    );
  }

  late final _spine_bone_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>('spine_bone_reset_constrained');
  late final _spine_bone_reset_constrained = _spine_bone_reset_constrainedPtr.asFunction<void Function(spine_bone)>();

  void spine_bone_constrained(
    spine_bone self,
  ) {
    return _spine_bone_constrained(
      self,
    );
  }

  late final _spine_bone_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>('spine_bone_constrained');
  late final _spine_bone_constrained = _spine_bone_constrainedPtr.asFunction<void Function(spine_bone)>();

  bool spine_bone_is_pose_equal_to_applied(
    spine_bone self,
  ) {
    return _spine_bone_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_bone_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_bone)>>('spine_bone_is_pose_equal_to_applied');
  late final _spine_bone_is_pose_equal_to_applied =
      _spine_bone_is_pose_equal_to_appliedPtr.asFunction<bool Function(spine_bone)>();

  bool spine_bone_is_active(
    spine_bone self,
  ) {
    return _spine_bone_is_active(
      self,
    );
  }

  late final _spine_bone_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_bone)>>('spine_bone_is_active');
  late final _spine_bone_is_active = _spine_bone_is_activePtr.asFunction<bool Function(spine_bone)>();

  void spine_bone_set_active(
    spine_bone self,
    bool active,
  ) {
    return _spine_bone_set_active(
      self,
      active,
    );
  }

  late final _spine_bone_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Bool)>>('spine_bone_set_active');
  late final _spine_bone_set_active = _spine_bone_set_activePtr.asFunction<void Function(spine_bone, bool)>();

  spine_rtti spine_bone_rtti() {
    return _spine_bone_rtti();
  }

  late final _spine_bone_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_bone_rtti');
  late final _spine_bone_rtti = _spine_bone_rttiPtr.asFunction<spine_rtti Function()>();

  spine_bone_data spine_bone_data_create(
    int index,
    ffi.Pointer<ffi.Char> name,
    spine_bone_data parent,
  ) {
    return _spine_bone_data_create(
      index,
      name,
      parent,
    );
  }

  late final _spine_bone_data_createPtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(ffi.Int, ffi.Pointer<ffi.Char>, spine_bone_data)>>(
          'spine_bone_data_create');
  late final _spine_bone_data_create =
      _spine_bone_data_createPtr.asFunction<spine_bone_data Function(int, ffi.Pointer<ffi.Char>, spine_bone_data)>();

  void spine_bone_data_dispose(
    spine_bone_data self,
  ) {
    return _spine_bone_data_dispose(
      self,
    );
  }

  late final _spine_bone_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data)>>('spine_bone_data_dispose');
  late final _spine_bone_data_dispose = _spine_bone_data_disposePtr.asFunction<void Function(spine_bone_data)>();

  /// The index of the bone in Skeleton.Bones
  int spine_bone_data_get_index(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_index(
      self,
    );
  }

  late final _spine_bone_data_get_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_bone_data)>>('spine_bone_data_get_index');
  late final _spine_bone_data_get_index = _spine_bone_data_get_indexPtr.asFunction<int Function(spine_bone_data)>();

  spine_bone_data spine_bone_data_get_parent(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_parent(
      self,
    );
  }

  late final _spine_bone_data_get_parentPtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_bone_data)>>('spine_bone_data_get_parent');
  late final _spine_bone_data_get_parent =
      _spine_bone_data_get_parentPtr.asFunction<spine_bone_data Function(spine_bone_data)>();

  double spine_bone_data_get_length(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_length(
      self,
    );
  }

  late final _spine_bone_data_get_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>('spine_bone_data_get_length');
  late final _spine_bone_data_get_length =
      _spine_bone_data_get_lengthPtr.asFunction<double Function(spine_bone_data)>();

  void spine_bone_data_set_length(
    spine_bone_data self,
    double inValue,
  ) {
    return _spine_bone_data_set_length(
      self,
      inValue,
    );
  }

  late final _spine_bone_data_set_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>('spine_bone_data_set_length');
  late final _spine_bone_data_set_length =
      _spine_bone_data_set_lengthPtr.asFunction<void Function(spine_bone_data, double)>();

  spine_color spine_bone_data_get_color(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_color(
      self,
    );
  }

  late final _spine_bone_data_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_bone_data)>>('spine_bone_data_get_color');
  late final _spine_bone_data_get_color =
      _spine_bone_data_get_colorPtr.asFunction<spine_color Function(spine_bone_data)>();

  ffi.Pointer<ffi.Char> spine_bone_data_get_icon(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_icon(
      self,
    );
  }

  late final _spine_bone_data_get_iconPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_bone_data)>>('spine_bone_data_get_icon');
  late final _spine_bone_data_get_icon =
      _spine_bone_data_get_iconPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_bone_data)>();

  void spine_bone_data_set_icon(
    spine_bone_data self,
    ffi.Pointer<ffi.Char> icon,
  ) {
    return _spine_bone_data_set_icon(
      self,
      icon,
    );
  }

  late final _spine_bone_data_set_iconPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Pointer<ffi.Char>)>>(
          'spine_bone_data_set_icon');
  late final _spine_bone_data_set_icon =
      _spine_bone_data_set_iconPtr.asFunction<void Function(spine_bone_data, ffi.Pointer<ffi.Char>)>();

  bool spine_bone_data_get_visible(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_visible(
      self,
    );
  }

  late final _spine_bone_data_get_visiblePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_bone_data)>>('spine_bone_data_get_visible');
  late final _spine_bone_data_get_visible =
      _spine_bone_data_get_visiblePtr.asFunction<bool Function(spine_bone_data)>();

  void spine_bone_data_set_visible(
    spine_bone_data self,
    bool inValue,
  ) {
    return _spine_bone_data_set_visible(
      self,
      inValue,
    );
  }

  late final _spine_bone_data_set_visiblePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Bool)>>('spine_bone_data_set_visible');
  late final _spine_bone_data_set_visible =
      _spine_bone_data_set_visiblePtr.asFunction<void Function(spine_bone_data, bool)>();

  spine_bone_local spine_bone_data_get_setup_pose(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_setup_pose(
      self,
    );
  }

  late final _spine_bone_data_get_setup_posePtr =
      _lookup<ffi.NativeFunction<spine_bone_local Function(spine_bone_data)>>('spine_bone_data_get_setup_pose');
  late final _spine_bone_data_get_setup_pose =
      _spine_bone_data_get_setup_posePtr.asFunction<spine_bone_local Function(spine_bone_data)>();

  /// The constraint's name, which is unique across all constraints in the skeleton
  /// of the same type.
  ffi.Pointer<ffi.Char> spine_bone_data_get_name(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_name(
      self,
    );
  }

  late final _spine_bone_data_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_bone_data)>>('spine_bone_data_get_name');
  late final _spine_bone_data_get_name =
      _spine_bone_data_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_bone_data)>();

  /// When true, Skeleton::updateWorldTransform(Physics) only updates this
  /// constraint if the Skeleton::getSkin() contains this constraint.
  ///
  /// See Skin::getConstraints().
  bool spine_bone_data_get_skin_required(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_skin_required(
      self,
    );
  }

  late final _spine_bone_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_bone_data)>>('spine_bone_data_get_skin_required');
  late final _spine_bone_data_get_skin_required =
      _spine_bone_data_get_skin_requiredPtr.asFunction<bool Function(spine_bone_data)>();

  void spine_bone_data_set_skin_required(
    spine_bone_data self,
    bool skinRequired,
  ) {
    return _spine_bone_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_bone_data_set_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Bool)>>('spine_bone_data_set_skin_required');
  late final _spine_bone_data_set_skin_required =
      _spine_bone_data_set_skin_requiredPtr.asFunction<void Function(spine_bone_data, bool)>();

  spine_bone_local spine_bone_local_create() {
    return _spine_bone_local_create();
  }

  late final _spine_bone_local_createPtr =
      _lookup<ffi.NativeFunction<spine_bone_local Function()>>('spine_bone_local_create');
  late final _spine_bone_local_create = _spine_bone_local_createPtr.asFunction<spine_bone_local Function()>();

  void spine_bone_local_dispose(
    spine_bone_local self,
  ) {
    return _spine_bone_local_dispose(
      self,
    );
  }

  late final _spine_bone_local_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local)>>('spine_bone_local_dispose');
  late final _spine_bone_local_dispose = _spine_bone_local_disposePtr.asFunction<void Function(spine_bone_local)>();

  void spine_bone_local_set(
    spine_bone_local self,
    spine_bone_local pose,
  ) {
    return _spine_bone_local_set(
      self,
      pose,
    );
  }

  late final _spine_bone_local_setPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local, spine_bone_local)>>('spine_bone_local_set');
  late final _spine_bone_local_set =
      _spine_bone_local_setPtr.asFunction<void Function(spine_bone_local, spine_bone_local)>();

  /// The local x translation.
  double spine_bone_local_get_x(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_x(
      self,
    );
  }

  late final _spine_bone_local_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>('spine_bone_local_get_x');
  late final _spine_bone_local_get_x = _spine_bone_local_get_xPtr.asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_x(
    spine_bone_local self,
    double x,
  ) {
    return _spine_bone_local_set_x(
      self,
      x,
    );
  }

  late final _spine_bone_local_set_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>('spine_bone_local_set_x');
  late final _spine_bone_local_set_x = _spine_bone_local_set_xPtr.asFunction<void Function(spine_bone_local, double)>();

  /// The local y translation.
  double spine_bone_local_get_y(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_y(
      self,
    );
  }

  late final _spine_bone_local_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>('spine_bone_local_get_y');
  late final _spine_bone_local_get_y = _spine_bone_local_get_yPtr.asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_y(
    spine_bone_local self,
    double y,
  ) {
    return _spine_bone_local_set_y(
      self,
      y,
    );
  }

  late final _spine_bone_local_set_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>('spine_bone_local_set_y');
  late final _spine_bone_local_set_y = _spine_bone_local_set_yPtr.asFunction<void Function(spine_bone_local, double)>();

  void spine_bone_local_set_position(
    spine_bone_local self,
    double x,
    double y,
  ) {
    return _spine_bone_local_set_position(
      self,
      x,
      y,
    );
  }

  late final _spine_bone_local_set_positionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float, ffi.Float)>>(
          'spine_bone_local_set_position');
  late final _spine_bone_local_set_position =
      _spine_bone_local_set_positionPtr.asFunction<void Function(spine_bone_local, double, double)>();

  /// The local rotation in degrees, counter clockwise.
  double spine_bone_local_get_rotation(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_rotation(
      self,
    );
  }

  late final _spine_bone_local_get_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>('spine_bone_local_get_rotation');
  late final _spine_bone_local_get_rotation =
      _spine_bone_local_get_rotationPtr.asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_rotation(
    spine_bone_local self,
    double rotation,
  ) {
    return _spine_bone_local_set_rotation(
      self,
      rotation,
    );
  }

  late final _spine_bone_local_set_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>('spine_bone_local_set_rotation');
  late final _spine_bone_local_set_rotation =
      _spine_bone_local_set_rotationPtr.asFunction<void Function(spine_bone_local, double)>();

  /// The local scaleX.
  double spine_bone_local_get_scale_x(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_scale_x(
      self,
    );
  }

  late final _spine_bone_local_get_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>('spine_bone_local_get_scale_x');
  late final _spine_bone_local_get_scale_x =
      _spine_bone_local_get_scale_xPtr.asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_scale_x(
    spine_bone_local self,
    double scaleX,
  ) {
    return _spine_bone_local_set_scale_x(
      self,
      scaleX,
    );
  }

  late final _spine_bone_local_set_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>('spine_bone_local_set_scale_x');
  late final _spine_bone_local_set_scale_x =
      _spine_bone_local_set_scale_xPtr.asFunction<void Function(spine_bone_local, double)>();

  /// The local scaleY.
  double spine_bone_local_get_scale_y(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_scale_y(
      self,
    );
  }

  late final _spine_bone_local_get_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>('spine_bone_local_get_scale_y');
  late final _spine_bone_local_get_scale_y =
      _spine_bone_local_get_scale_yPtr.asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_scale_y(
    spine_bone_local self,
    double scaleY,
  ) {
    return _spine_bone_local_set_scale_y(
      self,
      scaleY,
    );
  }

  late final _spine_bone_local_set_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>('spine_bone_local_set_scale_y');
  late final _spine_bone_local_set_scale_y =
      _spine_bone_local_set_scale_yPtr.asFunction<void Function(spine_bone_local, double)>();

  void spine_bone_local_set_scale_1(
    spine_bone_local self,
    double scaleX,
    double scaleY,
  ) {
    return _spine_bone_local_set_scale_1(
      self,
      scaleX,
      scaleY,
    );
  }

  late final _spine_bone_local_set_scale_1Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float, ffi.Float)>>(
          'spine_bone_local_set_scale_1');
  late final _spine_bone_local_set_scale_1 =
      _spine_bone_local_set_scale_1Ptr.asFunction<void Function(spine_bone_local, double, double)>();

  void spine_bone_local_set_scale_2(
    spine_bone_local self,
    double scale,
  ) {
    return _spine_bone_local_set_scale_2(
      self,
      scale,
    );
  }

  late final _spine_bone_local_set_scale_2Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>('spine_bone_local_set_scale_2');
  late final _spine_bone_local_set_scale_2 =
      _spine_bone_local_set_scale_2Ptr.asFunction<void Function(spine_bone_local, double)>();

  /// The local shearX.
  double spine_bone_local_get_shear_x(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_shear_x(
      self,
    );
  }

  late final _spine_bone_local_get_shear_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>('spine_bone_local_get_shear_x');
  late final _spine_bone_local_get_shear_x =
      _spine_bone_local_get_shear_xPtr.asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_shear_x(
    spine_bone_local self,
    double shearX,
  ) {
    return _spine_bone_local_set_shear_x(
      self,
      shearX,
    );
  }

  late final _spine_bone_local_set_shear_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>('spine_bone_local_set_shear_x');
  late final _spine_bone_local_set_shear_x =
      _spine_bone_local_set_shear_xPtr.asFunction<void Function(spine_bone_local, double)>();

  /// The local shearY.
  double spine_bone_local_get_shear_y(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_shear_y(
      self,
    );
  }

  late final _spine_bone_local_get_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>('spine_bone_local_get_shear_y');
  late final _spine_bone_local_get_shear_y =
      _spine_bone_local_get_shear_yPtr.asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_shear_y(
    spine_bone_local self,
    double shearY,
  ) {
    return _spine_bone_local_set_shear_y(
      self,
      shearY,
    );
  }

  late final _spine_bone_local_set_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>('spine_bone_local_set_shear_y');
  late final _spine_bone_local_set_shear_y =
      _spine_bone_local_set_shear_yPtr.asFunction<void Function(spine_bone_local, double)>();

  /// Determines how parent world transforms affect this bone.
  int spine_bone_local_get_inherit(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_inherit(
      self,
    );
  }

  late final _spine_bone_local_get_inheritPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_bone_local)>>('spine_bone_local_get_inherit');
  late final _spine_bone_local_get_inherit =
      _spine_bone_local_get_inheritPtr.asFunction<int Function(spine_bone_local)>();

  void spine_bone_local_set_inherit(
    spine_bone_local self,
    int inherit,
  ) {
    return _spine_bone_local_set_inherit(
      self,
      inherit,
    );
  }

  late final _spine_bone_local_set_inheritPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Int32)>>('spine_bone_local_set_inherit');
  late final _spine_bone_local_set_inherit =
      _spine_bone_local_set_inheritPtr.asFunction<void Function(spine_bone_local, int)>();

  void spine_bone_timeline_dispose(
    spine_bone_timeline self,
  ) {
    return _spine_bone_timeline_dispose(
      self,
    );
  }

  late final _spine_bone_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline)>>('spine_bone_timeline_dispose');
  late final _spine_bone_timeline_dispose =
      _spine_bone_timeline_disposePtr.asFunction<void Function(spine_bone_timeline)>();

  spine_rtti spine_bone_timeline_get_rtti(
    spine_bone_timeline self,
  ) {
    return _spine_bone_timeline_get_rtti(
      self,
    );
  }

  late final _spine_bone_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_bone_timeline)>>('spine_bone_timeline_get_rtti');
  late final _spine_bone_timeline_get_rtti =
      _spine_bone_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_bone_timeline)>();

  /// The index of the bone in Skeleton::getBones() that will be changed when this
  /// timeline is applied.
  int spine_bone_timeline_get_bone_index(
    spine_bone_timeline self,
  ) {
    return _spine_bone_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_bone_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_bone_timeline)>>('spine_bone_timeline_get_bone_index');
  late final _spine_bone_timeline_get_bone_index =
      _spine_bone_timeline_get_bone_indexPtr.asFunction<int Function(spine_bone_timeline)>();

  void spine_bone_timeline_set_bone_index(
    spine_bone_timeline self,
    int inValue,
  ) {
    return _spine_bone_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_bone_timeline_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline, ffi.Int)>>(
          'spine_bone_timeline_set_bone_index');
  late final _spine_bone_timeline_set_bone_index =
      _spine_bone_timeline_set_bone_indexPtr.asFunction<void Function(spine_bone_timeline, int)>();

  spine_rtti spine_bone_timeline_rtti() {
    return _spine_bone_timeline_rtti();
  }

  late final _spine_bone_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_bone_timeline_rtti');
  late final _spine_bone_timeline_rtti = _spine_bone_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_bone_timeline1_dispose(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_dispose(
      self,
    );
  }

  late final _spine_bone_timeline1_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline1)>>('spine_bone_timeline1_dispose');
  late final _spine_bone_timeline1_dispose =
      _spine_bone_timeline1_disposePtr.asFunction<void Function(spine_bone_timeline1)>();

  spine_rtti spine_bone_timeline1_get_rtti(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_rtti(
      self,
    );
  }

  late final _spine_bone_timeline1_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_bone_timeline1)>>('spine_bone_timeline1_get_rtti');
  late final _spine_bone_timeline1_get_rtti =
      _spine_bone_timeline1_get_rttiPtr.asFunction<spine_rtti Function(spine_bone_timeline1)>();

  void spine_bone_timeline1_apply(
    spine_bone_timeline1 self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_bone_timeline1_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_bone_timeline1_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_timeline1, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_bone_timeline1_apply');
  late final _spine_bone_timeline1_apply = _spine_bone_timeline1_applyPtr.asFunction<
      void Function(spine_bone_timeline1, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_bone_timeline1_get_bone_index(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_bone_index(
      self,
    );
  }

  late final _spine_bone_timeline1_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_bone_timeline1)>>('spine_bone_timeline1_get_bone_index');
  late final _spine_bone_timeline1_get_bone_index =
      _spine_bone_timeline1_get_bone_indexPtr.asFunction<int Function(spine_bone_timeline1)>();

  void spine_bone_timeline1_set_bone_index(
    spine_bone_timeline1 self,
    int inValue,
  ) {
    return _spine_bone_timeline1_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_bone_timeline1_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline1, ffi.Int)>>(
          'spine_bone_timeline1_set_bone_index');
  late final _spine_bone_timeline1_set_bone_index =
      _spine_bone_timeline1_set_bone_indexPtr.asFunction<void Function(spine_bone_timeline1, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_bone_timeline1_set_frame(
    spine_bone_timeline1 self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_bone_timeline1_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_bone_timeline1_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline1, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_bone_timeline1_set_frame');
  late final _spine_bone_timeline1_set_frame =
      _spine_bone_timeline1_set_framePtr.asFunction<void Function(spine_bone_timeline1, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_bone_timeline1_get_curve_value(
    spine_bone_timeline1 self,
    double time,
  ) {
    return _spine_bone_timeline1_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_bone_timeline1_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_timeline1, ffi.Float)>>(
          'spine_bone_timeline1_get_curve_value');
  late final _spine_bone_timeline1_get_curve_value =
      _spine_bone_timeline1_get_curve_valuePtr.asFunction<double Function(spine_bone_timeline1, double)>();

  double spine_bone_timeline1_get_relative_value(
    spine_bone_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_bone_timeline1_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_bone_timeline1_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_bone_timeline1, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_bone_timeline1_get_relative_value');
  late final _spine_bone_timeline1_get_relative_value = _spine_bone_timeline1_get_relative_valuePtr
      .asFunction<double Function(spine_bone_timeline1, double, double, int, double, double)>();

  double spine_bone_timeline1_get_absolute_value_1(
    spine_bone_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_bone_timeline1_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_bone_timeline1_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_bone_timeline1, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_bone_timeline1_get_absolute_value_1');
  late final _spine_bone_timeline1_get_absolute_value_1 = _spine_bone_timeline1_get_absolute_value_1Ptr
      .asFunction<double Function(spine_bone_timeline1, double, double, int, double, double)>();

  double spine_bone_timeline1_get_absolute_value_2(
    spine_bone_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_bone_timeline1_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_bone_timeline1_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_bone_timeline1, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_bone_timeline1_get_absolute_value_2');
  late final _spine_bone_timeline1_get_absolute_value_2 = _spine_bone_timeline1_get_absolute_value_2Ptr
      .asFunction<double Function(spine_bone_timeline1, double, double, int, double, double, double)>();

  double spine_bone_timeline1_get_scale_value(
    spine_bone_timeline1 self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_bone_timeline1_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_bone_timeline1_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_bone_timeline1, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_bone_timeline1_get_scale_value');
  late final _spine_bone_timeline1_get_scale_value = _spine_bone_timeline1_get_scale_valuePtr
      .asFunction<double Function(spine_bone_timeline1, double, double, int, int, double, double)>();

  void spine_bone_timeline1_set_linear(
    spine_bone_timeline1 self,
    int frame,
  ) {
    return _spine_bone_timeline1_set_linear(
      self,
      frame,
    );
  }

  late final _spine_bone_timeline1_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline1, ffi.Size)>>('spine_bone_timeline1_set_linear');
  late final _spine_bone_timeline1_set_linear =
      _spine_bone_timeline1_set_linearPtr.asFunction<void Function(spine_bone_timeline1, int)>();

  void spine_bone_timeline1_set_stepped(
    spine_bone_timeline1 self,
    int frame,
  ) {
    return _spine_bone_timeline1_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_bone_timeline1_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline1, ffi.Size)>>(
          'spine_bone_timeline1_set_stepped');
  late final _spine_bone_timeline1_set_stepped =
      _spine_bone_timeline1_set_steppedPtr.asFunction<void Function(spine_bone_timeline1, int)>();

  void spine_bone_timeline1_set_bezier(
    spine_bone_timeline1 self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_bone_timeline1_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_bone_timeline1_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_timeline1, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_bone_timeline1_set_bezier');
  late final _spine_bone_timeline1_set_bezier = _spine_bone_timeline1_set_bezierPtr.asFunction<
      void Function(
          spine_bone_timeline1, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_bone_timeline1_get_bezier_value(
    spine_bone_timeline1 self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_bone_timeline1_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_bone_timeline1_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_timeline1, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_bone_timeline1_get_bezier_value');
  late final _spine_bone_timeline1_get_bezier_value = _spine_bone_timeline1_get_bezier_valuePtr
      .asFunction<double Function(spine_bone_timeline1, double, int, int, int)>();

  spine_array_float spine_bone_timeline1_get_curves(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_curves(
      self,
    );
  }

  late final _spine_bone_timeline1_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_bone_timeline1)>>('spine_bone_timeline1_get_curves');
  late final _spine_bone_timeline1_get_curves =
      _spine_bone_timeline1_get_curvesPtr.asFunction<spine_array_float Function(spine_bone_timeline1)>();

  int spine_bone_timeline1_get_frame_entries(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_frame_entries(
      self,
    );
  }

  late final _spine_bone_timeline1_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_bone_timeline1)>>('spine_bone_timeline1_get_frame_entries');
  late final _spine_bone_timeline1_get_frame_entries =
      _spine_bone_timeline1_get_frame_entriesPtr.asFunction<int Function(spine_bone_timeline1)>();

  int spine_bone_timeline1_get_frame_count(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_frame_count(
      self,
    );
  }

  late final _spine_bone_timeline1_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_bone_timeline1)>>('spine_bone_timeline1_get_frame_count');
  late final _spine_bone_timeline1_get_frame_count =
      _spine_bone_timeline1_get_frame_countPtr.asFunction<int Function(spine_bone_timeline1)>();

  spine_array_float spine_bone_timeline1_get_frames(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_frames(
      self,
    );
  }

  late final _spine_bone_timeline1_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_bone_timeline1)>>('spine_bone_timeline1_get_frames');
  late final _spine_bone_timeline1_get_frames =
      _spine_bone_timeline1_get_framesPtr.asFunction<spine_array_float Function(spine_bone_timeline1)>();

  double spine_bone_timeline1_get_duration(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_duration(
      self,
    );
  }

  late final _spine_bone_timeline1_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_timeline1)>>('spine_bone_timeline1_get_duration');
  late final _spine_bone_timeline1_get_duration =
      _spine_bone_timeline1_get_durationPtr.asFunction<double Function(spine_bone_timeline1)>();

  spine_array_property_id spine_bone_timeline1_get_property_ids(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_property_ids(
      self,
    );
  }

  late final _spine_bone_timeline1_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_get_property_ids');
  late final _spine_bone_timeline1_get_property_ids =
      _spine_bone_timeline1_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_bone_timeline1)>();

  spine_rtti spine_bone_timeline1_rtti() {
    return _spine_bone_timeline1_rtti();
  }

  late final _spine_bone_timeline1_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_bone_timeline1_rtti');
  late final _spine_bone_timeline1_rtti = _spine_bone_timeline1_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_bone_timeline2_dispose(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_dispose(
      self,
    );
  }

  late final _spine_bone_timeline2_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline2)>>('spine_bone_timeline2_dispose');
  late final _spine_bone_timeline2_dispose =
      _spine_bone_timeline2_disposePtr.asFunction<void Function(spine_bone_timeline2)>();

  spine_rtti spine_bone_timeline2_get_rtti(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_rtti(
      self,
    );
  }

  late final _spine_bone_timeline2_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_bone_timeline2)>>('spine_bone_timeline2_get_rtti');
  late final _spine_bone_timeline2_get_rtti =
      _spine_bone_timeline2_get_rttiPtr.asFunction<spine_rtti Function(spine_bone_timeline2)>();

  void spine_bone_timeline2_apply(
    spine_bone_timeline2 self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_bone_timeline2_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_bone_timeline2_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_timeline2, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_bone_timeline2_apply');
  late final _spine_bone_timeline2_apply = _spine_bone_timeline2_applyPtr.asFunction<
      void Function(spine_bone_timeline2, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_bone_timeline2_get_bone_index(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_bone_index(
      self,
    );
  }

  late final _spine_bone_timeline2_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_bone_timeline2)>>('spine_bone_timeline2_get_bone_index');
  late final _spine_bone_timeline2_get_bone_index =
      _spine_bone_timeline2_get_bone_indexPtr.asFunction<int Function(spine_bone_timeline2)>();

  void spine_bone_timeline2_set_bone_index(
    spine_bone_timeline2 self,
    int inValue,
  ) {
    return _spine_bone_timeline2_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_bone_timeline2_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline2, ffi.Int)>>(
          'spine_bone_timeline2_set_bone_index');
  late final _spine_bone_timeline2_set_bone_index =
      _spine_bone_timeline2_set_bone_indexPtr.asFunction<void Function(spine_bone_timeline2, int)>();

  void spine_bone_timeline2_set_frame(
    spine_bone_timeline2 self,
    int frame,
    double time,
    double value1,
    double value2,
  ) {
    return _spine_bone_timeline2_set_frame(
      self,
      frame,
      time,
      value1,
      value2,
    );
  }

  late final _spine_bone_timeline2_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline2, ffi.Size, ffi.Float, ffi.Float, ffi.Float)>>(
          'spine_bone_timeline2_set_frame');
  late final _spine_bone_timeline2_set_frame =
      _spine_bone_timeline2_set_framePtr.asFunction<void Function(spine_bone_timeline2, int, double, double, double)>();

  void spine_bone_timeline2_set_linear(
    spine_bone_timeline2 self,
    int frame,
  ) {
    return _spine_bone_timeline2_set_linear(
      self,
      frame,
    );
  }

  late final _spine_bone_timeline2_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline2, ffi.Size)>>('spine_bone_timeline2_set_linear');
  late final _spine_bone_timeline2_set_linear =
      _spine_bone_timeline2_set_linearPtr.asFunction<void Function(spine_bone_timeline2, int)>();

  void spine_bone_timeline2_set_stepped(
    spine_bone_timeline2 self,
    int frame,
  ) {
    return _spine_bone_timeline2_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_bone_timeline2_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline2, ffi.Size)>>(
          'spine_bone_timeline2_set_stepped');
  late final _spine_bone_timeline2_set_stepped =
      _spine_bone_timeline2_set_steppedPtr.asFunction<void Function(spine_bone_timeline2, int)>();

  void spine_bone_timeline2_set_bezier(
    spine_bone_timeline2 self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_bone_timeline2_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_bone_timeline2_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_timeline2, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_bone_timeline2_set_bezier');
  late final _spine_bone_timeline2_set_bezier = _spine_bone_timeline2_set_bezierPtr.asFunction<
      void Function(
          spine_bone_timeline2, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_bone_timeline2_get_bezier_value(
    spine_bone_timeline2 self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_bone_timeline2_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_bone_timeline2_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_timeline2, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_bone_timeline2_get_bezier_value');
  late final _spine_bone_timeline2_get_bezier_value = _spine_bone_timeline2_get_bezier_valuePtr
      .asFunction<double Function(spine_bone_timeline2, double, int, int, int)>();

  spine_array_float spine_bone_timeline2_get_curves(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_curves(
      self,
    );
  }

  late final _spine_bone_timeline2_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_bone_timeline2)>>('spine_bone_timeline2_get_curves');
  late final _spine_bone_timeline2_get_curves =
      _spine_bone_timeline2_get_curvesPtr.asFunction<spine_array_float Function(spine_bone_timeline2)>();

  int spine_bone_timeline2_get_frame_entries(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_frame_entries(
      self,
    );
  }

  late final _spine_bone_timeline2_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_bone_timeline2)>>('spine_bone_timeline2_get_frame_entries');
  late final _spine_bone_timeline2_get_frame_entries =
      _spine_bone_timeline2_get_frame_entriesPtr.asFunction<int Function(spine_bone_timeline2)>();

  int spine_bone_timeline2_get_frame_count(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_frame_count(
      self,
    );
  }

  late final _spine_bone_timeline2_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_bone_timeline2)>>('spine_bone_timeline2_get_frame_count');
  late final _spine_bone_timeline2_get_frame_count =
      _spine_bone_timeline2_get_frame_countPtr.asFunction<int Function(spine_bone_timeline2)>();

  spine_array_float spine_bone_timeline2_get_frames(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_frames(
      self,
    );
  }

  late final _spine_bone_timeline2_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_bone_timeline2)>>('spine_bone_timeline2_get_frames');
  late final _spine_bone_timeline2_get_frames =
      _spine_bone_timeline2_get_framesPtr.asFunction<spine_array_float Function(spine_bone_timeline2)>();

  double spine_bone_timeline2_get_duration(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_duration(
      self,
    );
  }

  late final _spine_bone_timeline2_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_timeline2)>>('spine_bone_timeline2_get_duration');
  late final _spine_bone_timeline2_get_duration =
      _spine_bone_timeline2_get_durationPtr.asFunction<double Function(spine_bone_timeline2)>();

  spine_array_property_id spine_bone_timeline2_get_property_ids(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_property_ids(
      self,
    );
  }

  late final _spine_bone_timeline2_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_bone_timeline2)>>(
          'spine_bone_timeline2_get_property_ids');
  late final _spine_bone_timeline2_get_property_ids =
      _spine_bone_timeline2_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_bone_timeline2)>();

  spine_rtti spine_bone_timeline2_rtti() {
    return _spine_bone_timeline2_rtti();
  }

  late final _spine_bone_timeline2_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_bone_timeline2_rtti');
  late final _spine_bone_timeline2_rtti = _spine_bone_timeline2_rttiPtr.asFunction<spine_rtti Function()>();

  spine_bounding_box_attachment spine_bounding_box_attachment_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_bounding_box_attachment_create(
      name,
    );
  }

  late final _spine_bounding_box_attachment_createPtr =
      _lookup<ffi.NativeFunction<spine_bounding_box_attachment Function(ffi.Pointer<ffi.Char>)>>(
          'spine_bounding_box_attachment_create');
  late final _spine_bounding_box_attachment_create = _spine_bounding_box_attachment_createPtr
      .asFunction<spine_bounding_box_attachment Function(ffi.Pointer<ffi.Char>)>();

  void spine_bounding_box_attachment_dispose(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_dispose(
      self,
    );
  }

  late final _spine_bounding_box_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_dispose');
  late final _spine_bounding_box_attachment_dispose =
      _spine_bounding_box_attachment_disposePtr.asFunction<void Function(spine_bounding_box_attachment)>();

  spine_rtti spine_bounding_box_attachment_get_rtti(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_rtti(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_get_rtti');
  late final _spine_bounding_box_attachment_get_rtti =
      _spine_bounding_box_attachment_get_rttiPtr.asFunction<spine_rtti Function(spine_bounding_box_attachment)>();

  spine_color spine_bounding_box_attachment_get_color(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_color(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_get_color');
  late final _spine_bounding_box_attachment_get_color =
      _spine_bounding_box_attachment_get_colorPtr.asFunction<spine_color Function(spine_bounding_box_attachment)>();

  spine_attachment spine_bounding_box_attachment_copy(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_copy(
      self,
    );
  }

  late final _spine_bounding_box_attachment_copyPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_copy');
  late final _spine_bounding_box_attachment_copy =
      _spine_bounding_box_attachment_copyPtr.asFunction<spine_attachment Function(spine_bounding_box_attachment)>();

  /// Transforms the attachment's local vertices to world coordinates. If the
  /// slot's SlotPose::getDeform() is not empty, it is used to deform the vertices.
  ///
  /// See https://esotericsoftware.com/spine-runtime-skeletons#World-transforms
  /// World transforms in the Spine Runtimes Guide.
  ///
  /// @param start The index of the first vertices value to transform. Each vertex has 2 values, x and y.
  /// @param count The number of world vertex values to output. Must be < = WorldVerticesLength - start.
  /// @param worldVertices The output world vertices. Must have a length >= offset + count * stride / 2.
  /// @param offset The worldVertices index to begin writing values.
  /// @param stride The number of worldVertices entries between the value pairs written.
  void spine_bounding_box_attachment_compute_world_vertices_1(
    spine_bounding_box_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    ffi.Pointer<ffi.Float> worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_bounding_box_attachment_compute_world_vertices_1(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_bounding_box_attachment_compute_world_vertices_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bounding_box_attachment, spine_skeleton, spine_slot, ffi.Size, ffi.Size,
              ffi.Pointer<ffi.Float>, ffi.Size, ffi.Size)>>('spine_bounding_box_attachment_compute_world_vertices_1');
  late final _spine_bounding_box_attachment_compute_world_vertices_1 =
      _spine_bounding_box_attachment_compute_world_vertices_1Ptr.asFunction<
          void Function(
              spine_bounding_box_attachment, spine_skeleton, spine_slot, int, int, ffi.Pointer<ffi.Float>, int, int)>();

  void spine_bounding_box_attachment_compute_world_vertices_2(
    spine_bounding_box_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    spine_array_float worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_bounding_box_attachment_compute_world_vertices_2(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_bounding_box_attachment_compute_world_vertices_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bounding_box_attachment, spine_skeleton, spine_slot, ffi.Size, ffi.Size,
              spine_array_float, ffi.Size, ffi.Size)>>('spine_bounding_box_attachment_compute_world_vertices_2');
  late final _spine_bounding_box_attachment_compute_world_vertices_2 =
      _spine_bounding_box_attachment_compute_world_vertices_2Ptr.asFunction<
          void Function(
              spine_bounding_box_attachment, spine_skeleton, spine_slot, int, int, spine_array_float, int, int)>();

  /// Gets a unique ID for this attachment.
  int spine_bounding_box_attachment_get_id(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_id(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_idPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_get_id');
  late final _spine_bounding_box_attachment_get_id =
      _spine_bounding_box_attachment_get_idPtr.asFunction<int Function(spine_bounding_box_attachment)>();

  spine_array_int spine_bounding_box_attachment_get_bones(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_bones(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_int Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_get_bones');
  late final _spine_bounding_box_attachment_get_bones =
      _spine_bounding_box_attachment_get_bonesPtr.asFunction<spine_array_int Function(spine_bounding_box_attachment)>();

  void spine_bounding_box_attachment_set_bones(
    spine_bounding_box_attachment self,
    spine_array_int bones,
  ) {
    return _spine_bounding_box_attachment_set_bones(
      self,
      bones,
    );
  }

  late final _spine_bounding_box_attachment_set_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bounding_box_attachment, spine_array_int)>>(
          'spine_bounding_box_attachment_set_bones');
  late final _spine_bounding_box_attachment_set_bones = _spine_bounding_box_attachment_set_bonesPtr
      .asFunction<void Function(spine_bounding_box_attachment, spine_array_int)>();

  spine_array_float spine_bounding_box_attachment_get_vertices(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_vertices(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_verticesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_get_vertices');
  late final _spine_bounding_box_attachment_get_vertices = _spine_bounding_box_attachment_get_verticesPtr
      .asFunction<spine_array_float Function(spine_bounding_box_attachment)>();

  void spine_bounding_box_attachment_set_vertices(
    spine_bounding_box_attachment self,
    spine_array_float vertices,
  ) {
    return _spine_bounding_box_attachment_set_vertices(
      self,
      vertices,
    );
  }

  late final _spine_bounding_box_attachment_set_verticesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bounding_box_attachment, spine_array_float)>>(
          'spine_bounding_box_attachment_set_vertices');
  late final _spine_bounding_box_attachment_set_vertices = _spine_bounding_box_attachment_set_verticesPtr
      .asFunction<void Function(spine_bounding_box_attachment, spine_array_float)>();

  int spine_bounding_box_attachment_get_world_vertices_length(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_world_vertices_length(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_get_world_vertices_length');
  late final _spine_bounding_box_attachment_get_world_vertices_length =
      _spine_bounding_box_attachment_get_world_vertices_lengthPtr
          .asFunction<int Function(spine_bounding_box_attachment)>();

  void spine_bounding_box_attachment_set_world_vertices_length(
    spine_bounding_box_attachment self,
    int inValue,
  ) {
    return _spine_bounding_box_attachment_set_world_vertices_length(
      self,
      inValue,
    );
  }

  late final _spine_bounding_box_attachment_set_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bounding_box_attachment, ffi.Size)>>(
          'spine_bounding_box_attachment_set_world_vertices_length');
  late final _spine_bounding_box_attachment_set_world_vertices_length =
      _spine_bounding_box_attachment_set_world_vertices_lengthPtr
          .asFunction<void Function(spine_bounding_box_attachment, int)>();

  spine_attachment spine_bounding_box_attachment_get_timeline_attachment(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_timeline_attachment(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_timeline_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_get_timeline_attachment');
  late final _spine_bounding_box_attachment_get_timeline_attachment =
      _spine_bounding_box_attachment_get_timeline_attachmentPtr
          .asFunction<spine_attachment Function(spine_bounding_box_attachment)>();

  void spine_bounding_box_attachment_set_timeline_attachment(
    spine_bounding_box_attachment self,
    spine_attachment attachment,
  ) {
    return _spine_bounding_box_attachment_set_timeline_attachment(
      self,
      attachment,
    );
  }

  late final _spine_bounding_box_attachment_set_timeline_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bounding_box_attachment, spine_attachment)>>(
          'spine_bounding_box_attachment_set_timeline_attachment');
  late final _spine_bounding_box_attachment_set_timeline_attachment =
      _spine_bounding_box_attachment_set_timeline_attachmentPtr
          .asFunction<void Function(spine_bounding_box_attachment, spine_attachment)>();

  void spine_bounding_box_attachment_copy_to(
    spine_bounding_box_attachment self,
    spine_vertex_attachment other,
  ) {
    return _spine_bounding_box_attachment_copy_to(
      self,
      other,
    );
  }

  late final _spine_bounding_box_attachment_copy_toPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bounding_box_attachment, spine_vertex_attachment)>>(
          'spine_bounding_box_attachment_copy_to');
  late final _spine_bounding_box_attachment_copy_to = _spine_bounding_box_attachment_copy_toPtr
      .asFunction<void Function(spine_bounding_box_attachment, spine_vertex_attachment)>();

  ffi.Pointer<ffi.Char> spine_bounding_box_attachment_get_name(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_name(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_get_name');
  late final _spine_bounding_box_attachment_get_name = _spine_bounding_box_attachment_get_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_bounding_box_attachment)>();

  int spine_bounding_box_attachment_get_ref_count(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_get_ref_count');
  late final _spine_bounding_box_attachment_get_ref_count =
      _spine_bounding_box_attachment_get_ref_countPtr.asFunction<int Function(spine_bounding_box_attachment)>();

  void spine_bounding_box_attachment_reference(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_reference(
      self,
    );
  }

  late final _spine_bounding_box_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_reference');
  late final _spine_bounding_box_attachment_reference =
      _spine_bounding_box_attachment_referencePtr.asFunction<void Function(spine_bounding_box_attachment)>();

  void spine_bounding_box_attachment_dereference(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_dereference(
      self,
    );
  }

  late final _spine_bounding_box_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_dereference');
  late final _spine_bounding_box_attachment_dereference =
      _spine_bounding_box_attachment_dereferencePtr.asFunction<void Function(spine_bounding_box_attachment)>();

  spine_rtti spine_bounding_box_attachment_rtti() {
    return _spine_bounding_box_attachment_rtti();
  }

  late final _spine_bounding_box_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_bounding_box_attachment_rtti');
  late final _spine_bounding_box_attachment_rtti =
      _spine_bounding_box_attachment_rttiPtr.asFunction<spine_rtti Function()>();

  spine_clipping_attachment spine_clipping_attachment_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_clipping_attachment_create(
      name,
    );
  }

  late final _spine_clipping_attachment_createPtr =
      _lookup<ffi.NativeFunction<spine_clipping_attachment Function(ffi.Pointer<ffi.Char>)>>(
          'spine_clipping_attachment_create');
  late final _spine_clipping_attachment_create =
      _spine_clipping_attachment_createPtr.asFunction<spine_clipping_attachment Function(ffi.Pointer<ffi.Char>)>();

  void spine_clipping_attachment_dispose(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_dispose(
      self,
    );
  }

  late final _spine_clipping_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment)>>('spine_clipping_attachment_dispose');
  late final _spine_clipping_attachment_dispose =
      _spine_clipping_attachment_disposePtr.asFunction<void Function(spine_clipping_attachment)>();

  spine_rtti spine_clipping_attachment_get_rtti(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_rtti(
      self,
    );
  }

  late final _spine_clipping_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_clipping_attachment)>>('spine_clipping_attachment_get_rtti');
  late final _spine_clipping_attachment_get_rtti =
      _spine_clipping_attachment_get_rttiPtr.asFunction<spine_rtti Function(spine_clipping_attachment)>();

  spine_slot_data spine_clipping_attachment_get_end_slot(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_end_slot(
      self,
    );
  }

  late final _spine_clipping_attachment_get_end_slotPtr =
      _lookup<ffi.NativeFunction<spine_slot_data Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_get_end_slot');
  late final _spine_clipping_attachment_get_end_slot =
      _spine_clipping_attachment_get_end_slotPtr.asFunction<spine_slot_data Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_set_end_slot(
    spine_clipping_attachment self,
    spine_slot_data inValue,
  ) {
    return _spine_clipping_attachment_set_end_slot(
      self,
      inValue,
    );
  }

  late final _spine_clipping_attachment_set_end_slotPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment, spine_slot_data)>>(
          'spine_clipping_attachment_set_end_slot');
  late final _spine_clipping_attachment_set_end_slot = _spine_clipping_attachment_set_end_slotPtr
      .asFunction<void Function(spine_clipping_attachment, spine_slot_data)>();

  spine_color spine_clipping_attachment_get_color(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_color(
      self,
    );
  }

  late final _spine_clipping_attachment_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_get_color');
  late final _spine_clipping_attachment_get_color =
      _spine_clipping_attachment_get_colorPtr.asFunction<spine_color Function(spine_clipping_attachment)>();

  spine_attachment spine_clipping_attachment_copy(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_copy(
      self,
    );
  }

  late final _spine_clipping_attachment_copyPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_copy');
  late final _spine_clipping_attachment_copy =
      _spine_clipping_attachment_copyPtr.asFunction<spine_attachment Function(spine_clipping_attachment)>();

  /// Transforms the attachment's local vertices to world coordinates. If the
  /// slot's SlotPose::getDeform() is not empty, it is used to deform the vertices.
  ///
  /// See https://esotericsoftware.com/spine-runtime-skeletons#World-transforms
  /// World transforms in the Spine Runtimes Guide.
  ///
  /// @param start The index of the first vertices value to transform. Each vertex has 2 values, x and y.
  /// @param count The number of world vertex values to output. Must be < = WorldVerticesLength - start.
  /// @param worldVertices The output world vertices. Must have a length >= offset + count * stride / 2.
  /// @param offset The worldVertices index to begin writing values.
  /// @param stride The number of worldVertices entries between the value pairs written.
  void spine_clipping_attachment_compute_world_vertices_1(
    spine_clipping_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    ffi.Pointer<ffi.Float> worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_clipping_attachment_compute_world_vertices_1(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_clipping_attachment_compute_world_vertices_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_clipping_attachment, spine_skeleton, spine_slot, ffi.Size, ffi.Size,
              ffi.Pointer<ffi.Float>, ffi.Size, ffi.Size)>>('spine_clipping_attachment_compute_world_vertices_1');
  late final _spine_clipping_attachment_compute_world_vertices_1 =
      _spine_clipping_attachment_compute_world_vertices_1Ptr.asFunction<
          void Function(
              spine_clipping_attachment, spine_skeleton, spine_slot, int, int, ffi.Pointer<ffi.Float>, int, int)>();

  void spine_clipping_attachment_compute_world_vertices_2(
    spine_clipping_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    spine_array_float worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_clipping_attachment_compute_world_vertices_2(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_clipping_attachment_compute_world_vertices_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_clipping_attachment, spine_skeleton, spine_slot, ffi.Size, ffi.Size,
              spine_array_float, ffi.Size, ffi.Size)>>('spine_clipping_attachment_compute_world_vertices_2');
  late final _spine_clipping_attachment_compute_world_vertices_2 =
      _spine_clipping_attachment_compute_world_vertices_2Ptr.asFunction<
          void Function(
              spine_clipping_attachment, spine_skeleton, spine_slot, int, int, spine_array_float, int, int)>();

  /// Gets a unique ID for this attachment.
  int spine_clipping_attachment_get_id(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_id(
      self,
    );
  }

  late final _spine_clipping_attachment_get_idPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_clipping_attachment)>>('spine_clipping_attachment_get_id');
  late final _spine_clipping_attachment_get_id =
      _spine_clipping_attachment_get_idPtr.asFunction<int Function(spine_clipping_attachment)>();

  spine_array_int spine_clipping_attachment_get_bones(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_bones(
      self,
    );
  }

  late final _spine_clipping_attachment_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_int Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_get_bones');
  late final _spine_clipping_attachment_get_bones =
      _spine_clipping_attachment_get_bonesPtr.asFunction<spine_array_int Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_set_bones(
    spine_clipping_attachment self,
    spine_array_int bones,
  ) {
    return _spine_clipping_attachment_set_bones(
      self,
      bones,
    );
  }

  late final _spine_clipping_attachment_set_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment, spine_array_int)>>(
          'spine_clipping_attachment_set_bones');
  late final _spine_clipping_attachment_set_bones =
      _spine_clipping_attachment_set_bonesPtr.asFunction<void Function(spine_clipping_attachment, spine_array_int)>();

  spine_array_float spine_clipping_attachment_get_vertices(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_vertices(
      self,
    );
  }

  late final _spine_clipping_attachment_get_verticesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_get_vertices');
  late final _spine_clipping_attachment_get_vertices =
      _spine_clipping_attachment_get_verticesPtr.asFunction<spine_array_float Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_set_vertices(
    spine_clipping_attachment self,
    spine_array_float vertices,
  ) {
    return _spine_clipping_attachment_set_vertices(
      self,
      vertices,
    );
  }

  late final _spine_clipping_attachment_set_verticesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment, spine_array_float)>>(
          'spine_clipping_attachment_set_vertices');
  late final _spine_clipping_attachment_set_vertices = _spine_clipping_attachment_set_verticesPtr
      .asFunction<void Function(spine_clipping_attachment, spine_array_float)>();

  int spine_clipping_attachment_get_world_vertices_length(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_world_vertices_length(
      self,
    );
  }

  late final _spine_clipping_attachment_get_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_get_world_vertices_length');
  late final _spine_clipping_attachment_get_world_vertices_length =
      _spine_clipping_attachment_get_world_vertices_lengthPtr.asFunction<int Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_set_world_vertices_length(
    spine_clipping_attachment self,
    int inValue,
  ) {
    return _spine_clipping_attachment_set_world_vertices_length(
      self,
      inValue,
    );
  }

  late final _spine_clipping_attachment_set_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment, ffi.Size)>>(
          'spine_clipping_attachment_set_world_vertices_length');
  late final _spine_clipping_attachment_set_world_vertices_length =
      _spine_clipping_attachment_set_world_vertices_lengthPtr
          .asFunction<void Function(spine_clipping_attachment, int)>();

  spine_attachment spine_clipping_attachment_get_timeline_attachment(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_timeline_attachment(
      self,
    );
  }

  late final _spine_clipping_attachment_get_timeline_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_get_timeline_attachment');
  late final _spine_clipping_attachment_get_timeline_attachment = _spine_clipping_attachment_get_timeline_attachmentPtr
      .asFunction<spine_attachment Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_set_timeline_attachment(
    spine_clipping_attachment self,
    spine_attachment attachment,
  ) {
    return _spine_clipping_attachment_set_timeline_attachment(
      self,
      attachment,
    );
  }

  late final _spine_clipping_attachment_set_timeline_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment, spine_attachment)>>(
          'spine_clipping_attachment_set_timeline_attachment');
  late final _spine_clipping_attachment_set_timeline_attachment = _spine_clipping_attachment_set_timeline_attachmentPtr
      .asFunction<void Function(spine_clipping_attachment, spine_attachment)>();

  void spine_clipping_attachment_copy_to(
    spine_clipping_attachment self,
    spine_vertex_attachment other,
  ) {
    return _spine_clipping_attachment_copy_to(
      self,
      other,
    );
  }

  late final _spine_clipping_attachment_copy_toPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment, spine_vertex_attachment)>>(
          'spine_clipping_attachment_copy_to');
  late final _spine_clipping_attachment_copy_to = _spine_clipping_attachment_copy_toPtr
      .asFunction<void Function(spine_clipping_attachment, spine_vertex_attachment)>();

  ffi.Pointer<ffi.Char> spine_clipping_attachment_get_name(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_name(
      self,
    );
  }

  late final _spine_clipping_attachment_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_get_name');
  late final _spine_clipping_attachment_get_name =
      _spine_clipping_attachment_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_clipping_attachment)>();

  int spine_clipping_attachment_get_ref_count(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_clipping_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_get_ref_count');
  late final _spine_clipping_attachment_get_ref_count =
      _spine_clipping_attachment_get_ref_countPtr.asFunction<int Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_reference(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_reference(
      self,
    );
  }

  late final _spine_clipping_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment)>>('spine_clipping_attachment_reference');
  late final _spine_clipping_attachment_reference =
      _spine_clipping_attachment_referencePtr.asFunction<void Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_dereference(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_dereference(
      self,
    );
  }

  late final _spine_clipping_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_dereference');
  late final _spine_clipping_attachment_dereference =
      _spine_clipping_attachment_dereferencePtr.asFunction<void Function(spine_clipping_attachment)>();

  spine_rtti spine_clipping_attachment_rtti() {
    return _spine_clipping_attachment_rtti();
  }

  late final _spine_clipping_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_clipping_attachment_rtti');
  late final _spine_clipping_attachment_rtti = _spine_clipping_attachment_rttiPtr.asFunction<spine_rtti Function()>();

  spine_color spine_color_create() {
    return _spine_color_create();
  }

  late final _spine_color_createPtr = _lookup<ffi.NativeFunction<spine_color Function()>>('spine_color_create');
  late final _spine_color_create = _spine_color_createPtr.asFunction<spine_color Function()>();

  spine_color spine_color_create2(
    double r,
    double g,
    double b,
    double a,
  ) {
    return _spine_color_create2(
      r,
      g,
      b,
      a,
    );
  }

  late final _spine_color_create2Ptr =
      _lookup<ffi.NativeFunction<spine_color Function(ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
          'spine_color_create2');
  late final _spine_color_create2 =
      _spine_color_create2Ptr.asFunction<spine_color Function(double, double, double, double)>();

  void spine_color_dispose(
    spine_color self,
  ) {
    return _spine_color_dispose(
      self,
    );
  }

  late final _spine_color_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color)>>('spine_color_dispose');
  late final _spine_color_dispose = _spine_color_disposePtr.asFunction<void Function(spine_color)>();

  spine_color spine_color_set_1(
    spine_color self,
    double _r,
    double _g,
    double _b,
    double _a,
  ) {
    return _spine_color_set_1(
      self,
      _r,
      _g,
      _b,
      _a,
    );
  }

  late final _spine_color_set_1Ptr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_color, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
          'spine_color_set_1');
  late final _spine_color_set_1 =
      _spine_color_set_1Ptr.asFunction<spine_color Function(spine_color, double, double, double, double)>();

  spine_color spine_color_set_2(
    spine_color self,
    double _r,
    double _g,
    double _b,
  ) {
    return _spine_color_set_2(
      self,
      _r,
      _g,
      _b,
    );
  }

  late final _spine_color_set_2Ptr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_color, ffi.Float, ffi.Float, ffi.Float)>>(
          'spine_color_set_2');
  late final _spine_color_set_2 =
      _spine_color_set_2Ptr.asFunction<spine_color Function(spine_color, double, double, double)>();

  spine_color spine_color_set_3(
    spine_color self,
    spine_color other,
  ) {
    return _spine_color_set_3(
      self,
      other,
    );
  }

  late final _spine_color_set_3Ptr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_color, spine_color)>>('spine_color_set_3');
  late final _spine_color_set_3 = _spine_color_set_3Ptr.asFunction<spine_color Function(spine_color, spine_color)>();

  spine_color spine_color_add_1(
    spine_color self,
    double _r,
    double _g,
    double _b,
    double _a,
  ) {
    return _spine_color_add_1(
      self,
      _r,
      _g,
      _b,
      _a,
    );
  }

  late final _spine_color_add_1Ptr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_color, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
          'spine_color_add_1');
  late final _spine_color_add_1 =
      _spine_color_add_1Ptr.asFunction<spine_color Function(spine_color, double, double, double, double)>();

  spine_color spine_color_add_2(
    spine_color self,
    double _r,
    double _g,
    double _b,
  ) {
    return _spine_color_add_2(
      self,
      _r,
      _g,
      _b,
    );
  }

  late final _spine_color_add_2Ptr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_color, ffi.Float, ffi.Float, ffi.Float)>>(
          'spine_color_add_2');
  late final _spine_color_add_2 =
      _spine_color_add_2Ptr.asFunction<spine_color Function(spine_color, double, double, double)>();

  spine_color spine_color_add_3(
    spine_color self,
    spine_color other,
  ) {
    return _spine_color_add_3(
      self,
      other,
    );
  }

  late final _spine_color_add_3Ptr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_color, spine_color)>>('spine_color_add_3');
  late final _spine_color_add_3 = _spine_color_add_3Ptr.asFunction<spine_color Function(spine_color, spine_color)>();

  spine_color spine_color_clamp(
    spine_color self,
  ) {
    return _spine_color_clamp(
      self,
    );
  }

  late final _spine_color_clampPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_color)>>('spine_color_clamp');
  late final _spine_color_clamp = _spine_color_clampPtr.asFunction<spine_color Function(spine_color)>();

  double spine_color_parse_hex(
    ffi.Pointer<ffi.Char> value,
    int index,
  ) {
    return _spine_color_parse_hex(
      value,
      index,
    );
  }

  late final _spine_color_parse_hexPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(ffi.Pointer<ffi.Char>, ffi.Size)>>('spine_color_parse_hex');
  late final _spine_color_parse_hex =
      _spine_color_parse_hexPtr.asFunction<double Function(ffi.Pointer<ffi.Char>, int)>();

  /// Convert packed RGBA8888 integer to Color
  void spine_color_rgba8888_to_color(
    spine_color color,
    int value,
  ) {
    return _spine_color_rgba8888_to_color(
      color,
      value,
    );
  }

  late final _spine_color_rgba8888_to_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color, ffi.Int)>>('spine_color_rgba8888_to_color');
  late final _spine_color_rgba8888_to_color =
      _spine_color_rgba8888_to_colorPtr.asFunction<void Function(spine_color, int)>();

  /// Convert packed RGB888 integer to Color (no alpha)
  void spine_color_rgb888_to_color(
    spine_color color,
    int value,
  ) {
    return _spine_color_rgb888_to_color(
      color,
      value,
    );
  }

  late final _spine_color_rgb888_to_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color, ffi.Int)>>('spine_color_rgb888_to_color');
  late final _spine_color_rgb888_to_color =
      _spine_color_rgb888_to_colorPtr.asFunction<void Function(spine_color, int)>();

  double spine_color_get_r(
    spine_color self,
  ) {
    return _spine_color_get_r(
      self,
    );
  }

  late final _spine_color_get_rPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_color)>>('spine_color_get_r');
  late final _spine_color_get_r = _spine_color_get_rPtr.asFunction<double Function(spine_color)>();

  void spine_color_set_r(
    spine_color self,
    double value,
  ) {
    return _spine_color_set_r(
      self,
      value,
    );
  }

  late final _spine_color_set_rPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color, ffi.Float)>>('spine_color_set_r');
  late final _spine_color_set_r = _spine_color_set_rPtr.asFunction<void Function(spine_color, double)>();

  double spine_color_get_g(
    spine_color self,
  ) {
    return _spine_color_get_g(
      self,
    );
  }

  late final _spine_color_get_gPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_color)>>('spine_color_get_g');
  late final _spine_color_get_g = _spine_color_get_gPtr.asFunction<double Function(spine_color)>();

  void spine_color_set_g(
    spine_color self,
    double value,
  ) {
    return _spine_color_set_g(
      self,
      value,
    );
  }

  late final _spine_color_set_gPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color, ffi.Float)>>('spine_color_set_g');
  late final _spine_color_set_g = _spine_color_set_gPtr.asFunction<void Function(spine_color, double)>();

  double spine_color_get_b(
    spine_color self,
  ) {
    return _spine_color_get_b(
      self,
    );
  }

  late final _spine_color_get_bPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_color)>>('spine_color_get_b');
  late final _spine_color_get_b = _spine_color_get_bPtr.asFunction<double Function(spine_color)>();

  void spine_color_set_b(
    spine_color self,
    double value,
  ) {
    return _spine_color_set_b(
      self,
      value,
    );
  }

  late final _spine_color_set_bPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color, ffi.Float)>>('spine_color_set_b');
  late final _spine_color_set_b = _spine_color_set_bPtr.asFunction<void Function(spine_color, double)>();

  double spine_color_get_a(
    spine_color self,
  ) {
    return _spine_color_get_a(
      self,
    );
  }

  late final _spine_color_get_aPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_color)>>('spine_color_get_a');
  late final _spine_color_get_a = _spine_color_get_aPtr.asFunction<double Function(spine_color)>();

  void spine_color_set_a(
    spine_color self,
    double value,
  ) {
    return _spine_color_set_a(
      self,
      value,
    );
  }

  late final _spine_color_set_aPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color, ffi.Float)>>('spine_color_set_a');
  late final _spine_color_set_a = _spine_color_set_aPtr.asFunction<void Function(spine_color, double)>();

  void spine_constraint_dispose(
    spine_constraint self,
  ) {
    return _spine_constraint_dispose(
      self,
    );
  }

  late final _spine_constraint_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint)>>('spine_constraint_dispose');
  late final _spine_constraint_dispose = _spine_constraint_disposePtr.asFunction<void Function(spine_constraint)>();

  spine_rtti spine_constraint_get_rtti(
    spine_constraint self,
  ) {
    return _spine_constraint_get_rtti(
      self,
    );
  }

  late final _spine_constraint_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_constraint)>>('spine_constraint_get_rtti');
  late final _spine_constraint_get_rtti =
      _spine_constraint_get_rttiPtr.asFunction<spine_rtti Function(spine_constraint)>();

  spine_constraint_data spine_constraint_get_data(
    spine_constraint self,
  ) {
    return _spine_constraint_get_data(
      self,
    );
  }

  late final _spine_constraint_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_constraint_data Function(spine_constraint)>>('spine_constraint_get_data');
  late final _spine_constraint_get_data =
      _spine_constraint_get_dataPtr.asFunction<spine_constraint_data Function(spine_constraint)>();

  void spine_constraint_sort(
    spine_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_constraint_sort(
      self,
      skeleton,
    );
  }

  late final _spine_constraint_sortPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint, spine_skeleton)>>('spine_constraint_sort');
  late final _spine_constraint_sort =
      _spine_constraint_sortPtr.asFunction<void Function(spine_constraint, spine_skeleton)>();

  bool spine_constraint_is_source_active(
    spine_constraint self,
  ) {
    return _spine_constraint_is_source_active(
      self,
    );
  }

  late final _spine_constraint_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_constraint)>>('spine_constraint_is_source_active');
  late final _spine_constraint_is_source_active =
      _spine_constraint_is_source_activePtr.asFunction<bool Function(spine_constraint)>();

  /// Inherited from Update
  void spine_constraint_update(
    spine_constraint self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_constraint_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_constraint_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint, spine_skeleton, ffi.Int32)>>(
          'spine_constraint_update');
  late final _spine_constraint_update =
      _spine_constraint_updatePtr.asFunction<void Function(spine_constraint, spine_skeleton, int)>();

  spine_rtti spine_constraint_rtti() {
    return _spine_constraint_rtti();
  }

  late final _spine_constraint_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_constraint_rtti');
  late final _spine_constraint_rtti = _spine_constraint_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_constraint_data_dispose(
    spine_constraint_data self,
  ) {
    return _spine_constraint_data_dispose(
      self,
    );
  }

  late final _spine_constraint_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_data)>>('spine_constraint_data_dispose');
  late final _spine_constraint_data_dispose =
      _spine_constraint_data_disposePtr.asFunction<void Function(spine_constraint_data)>();

  spine_rtti spine_constraint_data_get_rtti(
    spine_constraint_data self,
  ) {
    return _spine_constraint_data_get_rtti(
      self,
    );
  }

  late final _spine_constraint_data_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_constraint_data)>>('spine_constraint_data_get_rtti');
  late final _spine_constraint_data_get_rtti =
      _spine_constraint_data_get_rttiPtr.asFunction<spine_rtti Function(spine_constraint_data)>();

  spine_constraint spine_constraint_data_create_method(
    spine_constraint_data self,
    spine_skeleton skeleton,
  ) {
    return _spine_constraint_data_create_method(
      self,
      skeleton,
    );
  }

  late final _spine_constraint_data_create_methodPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_constraint_data, spine_skeleton)>>(
          'spine_constraint_data_create_method');
  late final _spine_constraint_data_create_method = _spine_constraint_data_create_methodPtr
      .asFunction<spine_constraint Function(spine_constraint_data, spine_skeleton)>();

  ffi.Pointer<ffi.Char> spine_constraint_data_get_name(
    spine_constraint_data self,
  ) {
    return _spine_constraint_data_get_name(
      self,
    );
  }

  late final _spine_constraint_data_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_constraint_data)>>(
          'spine_constraint_data_get_name');
  late final _spine_constraint_data_get_name =
      _spine_constraint_data_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_constraint_data)>();

  bool spine_constraint_data_get_skin_required(
    spine_constraint_data self,
  ) {
    return _spine_constraint_data_get_skin_required(
      self,
    );
  }

  late final _spine_constraint_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_constraint_data)>>('spine_constraint_data_get_skin_required');
  late final _spine_constraint_data_get_skin_required =
      _spine_constraint_data_get_skin_requiredPtr.asFunction<bool Function(spine_constraint_data)>();

  spine_rtti spine_constraint_data_rtti() {
    return _spine_constraint_data_rtti();
  }

  late final _spine_constraint_data_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_constraint_data_rtti');
  late final _spine_constraint_data_rtti = _spine_constraint_data_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_constraint_timeline_dispose(
    spine_constraint_timeline self,
  ) {
    return _spine_constraint_timeline_dispose(
      self,
    );
  }

  late final _spine_constraint_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_timeline)>>('spine_constraint_timeline_dispose');
  late final _spine_constraint_timeline_dispose =
      _spine_constraint_timeline_disposePtr.asFunction<void Function(spine_constraint_timeline)>();

  spine_rtti spine_constraint_timeline_get_rtti(
    spine_constraint_timeline self,
  ) {
    return _spine_constraint_timeline_get_rtti(
      self,
    );
  }

  late final _spine_constraint_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_constraint_timeline)>>('spine_constraint_timeline_get_rtti');
  late final _spine_constraint_timeline_get_rtti =
      _spine_constraint_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_constraint_timeline)>();

  /// The index of the constraint in Skeleton::getConstraints() that will be
  /// changed when this timeline is applied.
  int spine_constraint_timeline_get_constraint_index(
    spine_constraint_timeline self,
  ) {
    return _spine_constraint_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_constraint_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_get_constraint_index');
  late final _spine_constraint_timeline_get_constraint_index =
      _spine_constraint_timeline_get_constraint_indexPtr.asFunction<int Function(spine_constraint_timeline)>();

  void spine_constraint_timeline_set_constraint_index(
    spine_constraint_timeline self,
    int inValue,
  ) {
    return _spine_constraint_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_constraint_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_timeline, ffi.Int)>>(
          'spine_constraint_timeline_set_constraint_index');
  late final _spine_constraint_timeline_set_constraint_index =
      _spine_constraint_timeline_set_constraint_indexPtr.asFunction<void Function(spine_constraint_timeline, int)>();

  spine_rtti spine_constraint_timeline_rtti() {
    return _spine_constraint_timeline_rtti();
  }

  late final _spine_constraint_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_constraint_timeline_rtti');
  late final _spine_constraint_timeline_rtti = _spine_constraint_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_constraint_timeline1_dispose(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_dispose(
      self,
    );
  }

  late final _spine_constraint_timeline1_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_timeline1)>>('spine_constraint_timeline1_dispose');
  late final _spine_constraint_timeline1_dispose =
      _spine_constraint_timeline1_disposePtr.asFunction<void Function(spine_constraint_timeline1)>();

  spine_rtti spine_constraint_timeline1_get_rtti(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_rtti(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_get_rtti');
  late final _spine_constraint_timeline1_get_rtti =
      _spine_constraint_timeline1_get_rttiPtr.asFunction<spine_rtti Function(spine_constraint_timeline1)>();

  int spine_constraint_timeline1_get_constraint_index(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_constraint_index(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_get_constraint_index');
  late final _spine_constraint_timeline1_get_constraint_index =
      _spine_constraint_timeline1_get_constraint_indexPtr.asFunction<int Function(spine_constraint_timeline1)>();

  void spine_constraint_timeline1_set_constraint_index(
    spine_constraint_timeline1 self,
    int inValue,
  ) {
    return _spine_constraint_timeline1_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_constraint_timeline1_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_timeline1, ffi.Int)>>(
          'spine_constraint_timeline1_set_constraint_index');
  late final _spine_constraint_timeline1_set_constraint_index =
      _spine_constraint_timeline1_set_constraint_indexPtr.asFunction<void Function(spine_constraint_timeline1, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_constraint_timeline1_set_frame(
    spine_constraint_timeline1 self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_constraint_timeline1_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_constraint_timeline1_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_timeline1, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_constraint_timeline1_set_frame');
  late final _spine_constraint_timeline1_set_frame = _spine_constraint_timeline1_set_framePtr
      .asFunction<void Function(spine_constraint_timeline1, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_constraint_timeline1_get_curve_value(
    spine_constraint_timeline1 self,
    double time,
  ) {
    return _spine_constraint_timeline1_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_constraint_timeline1_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_constraint_timeline1, ffi.Float)>>(
          'spine_constraint_timeline1_get_curve_value');
  late final _spine_constraint_timeline1_get_curve_value =
      _spine_constraint_timeline1_get_curve_valuePtr.asFunction<double Function(spine_constraint_timeline1, double)>();

  double spine_constraint_timeline1_get_relative_value(
    spine_constraint_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_constraint_timeline1_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_constraint_timeline1_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_constraint_timeline1, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_constraint_timeline1_get_relative_value');
  late final _spine_constraint_timeline1_get_relative_value = _spine_constraint_timeline1_get_relative_valuePtr
      .asFunction<double Function(spine_constraint_timeline1, double, double, int, double, double)>();

  double spine_constraint_timeline1_get_absolute_value_1(
    spine_constraint_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_constraint_timeline1_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_constraint_timeline1_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_constraint_timeline1, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_constraint_timeline1_get_absolute_value_1');
  late final _spine_constraint_timeline1_get_absolute_value_1 = _spine_constraint_timeline1_get_absolute_value_1Ptr
      .asFunction<double Function(spine_constraint_timeline1, double, double, int, double, double)>();

  double spine_constraint_timeline1_get_absolute_value_2(
    spine_constraint_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_constraint_timeline1_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_constraint_timeline1_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_constraint_timeline1, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_constraint_timeline1_get_absolute_value_2');
  late final _spine_constraint_timeline1_get_absolute_value_2 = _spine_constraint_timeline1_get_absolute_value_2Ptr
      .asFunction<double Function(spine_constraint_timeline1, double, double, int, double, double, double)>();

  double spine_constraint_timeline1_get_scale_value(
    spine_constraint_timeline1 self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_constraint_timeline1_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_constraint_timeline1_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_constraint_timeline1, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_constraint_timeline1_get_scale_value');
  late final _spine_constraint_timeline1_get_scale_value = _spine_constraint_timeline1_get_scale_valuePtr
      .asFunction<double Function(spine_constraint_timeline1, double, double, int, int, double, double)>();

  void spine_constraint_timeline1_set_linear(
    spine_constraint_timeline1 self,
    int frame,
  ) {
    return _spine_constraint_timeline1_set_linear(
      self,
      frame,
    );
  }

  late final _spine_constraint_timeline1_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_timeline1, ffi.Size)>>(
          'spine_constraint_timeline1_set_linear');
  late final _spine_constraint_timeline1_set_linear =
      _spine_constraint_timeline1_set_linearPtr.asFunction<void Function(spine_constraint_timeline1, int)>();

  void spine_constraint_timeline1_set_stepped(
    spine_constraint_timeline1 self,
    int frame,
  ) {
    return _spine_constraint_timeline1_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_constraint_timeline1_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_timeline1, ffi.Size)>>(
          'spine_constraint_timeline1_set_stepped');
  late final _spine_constraint_timeline1_set_stepped =
      _spine_constraint_timeline1_set_steppedPtr.asFunction<void Function(spine_constraint_timeline1, int)>();

  void spine_constraint_timeline1_set_bezier(
    spine_constraint_timeline1 self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_constraint_timeline1_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_constraint_timeline1_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_constraint_timeline1, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_constraint_timeline1_set_bezier');
  late final _spine_constraint_timeline1_set_bezier = _spine_constraint_timeline1_set_bezierPtr.asFunction<
      void Function(spine_constraint_timeline1, int, int, double, double, double, double, double, double, double,
          double, double)>();

  double spine_constraint_timeline1_get_bezier_value(
    spine_constraint_timeline1 self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_constraint_timeline1_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_constraint_timeline1_get_bezier_valuePtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_constraint_timeline1, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
      'spine_constraint_timeline1_get_bezier_value');
  late final _spine_constraint_timeline1_get_bezier_value = _spine_constraint_timeline1_get_bezier_valuePtr
      .asFunction<double Function(spine_constraint_timeline1, double, int, int, int)>();

  spine_array_float spine_constraint_timeline1_get_curves(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_curves(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_get_curves');
  late final _spine_constraint_timeline1_get_curves =
      _spine_constraint_timeline1_get_curvesPtr.asFunction<spine_array_float Function(spine_constraint_timeline1)>();

  /// Sets the value(s) for the specified time.
  ///
  /// @param skeleton The skeleton the timeline is being applied to. This provides access to the bones, slots, and other skeleton components the timeline may change.
  /// @param lastTime lastTime The time this timeline was last applied. Timelines such as EventTimeline trigger only at specific times rather than every frame. In that case, the timeline triggers everything between lastTime (exclusive) and time (inclusive).
  /// @param time The time within the animation. Most timelines find the key before and the key after this time so they can interpolate between the keys.
  /// @param events If any events are fired, they are added to this array. Can be NULL to ignore firing events or if the timeline does not fire events. May be NULL.
  /// @param alpha alpha 0 applies the current or setup pose value (depending on pose parameter). 1 applies the timeline value. Between 0 and 1 applies a value between the current or setup pose and the timeline value. By adjusting alpha over time, an animation can be mixed in or out. alpha can also be useful to apply animations on top of each other (layered).
  /// @param blend Controls how mixing is applied when alpha is than 1.
  /// @param direction Indicates whether the timeline is mixing in or out. Used by timelines which perform instant transitions such as DrawOrderTimeline and AttachmentTimeline.
  /// @param appliedPose True to modify the applied pose.
  void spine_constraint_timeline1_apply(
    spine_constraint_timeline1 self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_constraint_timeline1_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_constraint_timeline1_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_constraint_timeline1, spine_skeleton, ffi.Float, ffi.Float, spine_array_event,
              ffi.Float, ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_constraint_timeline1_apply');
  late final _spine_constraint_timeline1_apply = _spine_constraint_timeline1_applyPtr.asFunction<
      void Function(
          spine_constraint_timeline1, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_constraint_timeline1_get_frame_entries(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_frame_entries(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_get_frame_entries');
  late final _spine_constraint_timeline1_get_frame_entries =
      _spine_constraint_timeline1_get_frame_entriesPtr.asFunction<int Function(spine_constraint_timeline1)>();

  int spine_constraint_timeline1_get_frame_count(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_frame_count(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_get_frame_count');
  late final _spine_constraint_timeline1_get_frame_count =
      _spine_constraint_timeline1_get_frame_countPtr.asFunction<int Function(spine_constraint_timeline1)>();

  spine_array_float spine_constraint_timeline1_get_frames(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_frames(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_get_frames');
  late final _spine_constraint_timeline1_get_frames =
      _spine_constraint_timeline1_get_framesPtr.asFunction<spine_array_float Function(spine_constraint_timeline1)>();

  double spine_constraint_timeline1_get_duration(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_duration(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_get_duration');
  late final _spine_constraint_timeline1_get_duration =
      _spine_constraint_timeline1_get_durationPtr.asFunction<double Function(spine_constraint_timeline1)>();

  spine_array_property_id spine_constraint_timeline1_get_property_ids(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_property_ids(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_get_property_ids');
  late final _spine_constraint_timeline1_get_property_ids = _spine_constraint_timeline1_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_constraint_timeline1)>();

  spine_rtti spine_constraint_timeline1_rtti() {
    return _spine_constraint_timeline1_rtti();
  }

  late final _spine_constraint_timeline1_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_constraint_timeline1_rtti');
  late final _spine_constraint_timeline1_rtti = _spine_constraint_timeline1_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_curve_timeline_dispose(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_dispose(
      self,
    );
  }

  late final _spine_curve_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_curve_timeline)>>('spine_curve_timeline_dispose');
  late final _spine_curve_timeline_dispose =
      _spine_curve_timeline_disposePtr.asFunction<void Function(spine_curve_timeline)>();

  spine_rtti spine_curve_timeline_get_rtti(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_rtti(
      self,
    );
  }

  late final _spine_curve_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_curve_timeline)>>('spine_curve_timeline_get_rtti');
  late final _spine_curve_timeline_get_rtti =
      _spine_curve_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_curve_timeline)>();

  void spine_curve_timeline_set_linear(
    spine_curve_timeline self,
    int frame,
  ) {
    return _spine_curve_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_curve_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_curve_timeline, ffi.Size)>>('spine_curve_timeline_set_linear');
  late final _spine_curve_timeline_set_linear =
      _spine_curve_timeline_set_linearPtr.asFunction<void Function(spine_curve_timeline, int)>();

  void spine_curve_timeline_set_stepped(
    spine_curve_timeline self,
    int frame,
  ) {
    return _spine_curve_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_curve_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_curve_timeline, ffi.Size)>>(
          'spine_curve_timeline_set_stepped');
  late final _spine_curve_timeline_set_stepped =
      _spine_curve_timeline_set_steppedPtr.asFunction<void Function(spine_curve_timeline, int)>();

  void spine_curve_timeline_set_bezier(
    spine_curve_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_curve_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_curve_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_curve_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_curve_timeline_set_bezier');
  late final _spine_curve_timeline_set_bezier = _spine_curve_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_curve_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_curve_timeline_get_bezier_value(
    spine_curve_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_curve_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_curve_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_curve_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_curve_timeline_get_bezier_value');
  late final _spine_curve_timeline_get_bezier_value = _spine_curve_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_curve_timeline, double, int, int, int)>();

  spine_array_float spine_curve_timeline_get_curves(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_curves(
      self,
    );
  }

  late final _spine_curve_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_curve_timeline)>>('spine_curve_timeline_get_curves');
  late final _spine_curve_timeline_get_curves =
      _spine_curve_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_curve_timeline)>();

  /// Sets the value(s) for the specified time.
  ///
  /// @param skeleton The skeleton the timeline is being applied to. This provides access to the bones, slots, and other skeleton components the timeline may change.
  /// @param lastTime lastTime The time this timeline was last applied. Timelines such as EventTimeline trigger only at specific times rather than every frame. In that case, the timeline triggers everything between lastTime (exclusive) and time (inclusive).
  /// @param time The time within the animation. Most timelines find the key before and the key after this time so they can interpolate between the keys.
  /// @param events If any events are fired, they are added to this array. Can be NULL to ignore firing events or if the timeline does not fire events. May be NULL.
  /// @param alpha alpha 0 applies the current or setup pose value (depending on pose parameter). 1 applies the timeline value. Between 0 and 1 applies a value between the current or setup pose and the timeline value. By adjusting alpha over time, an animation can be mixed in or out. alpha can also be useful to apply animations on top of each other (layered).
  /// @param blend Controls how mixing is applied when alpha is than 1.
  /// @param direction Indicates whether the timeline is mixing in or out. Used by timelines which perform instant transitions such as DrawOrderTimeline and AttachmentTimeline.
  /// @param appliedPose True to modify the applied pose.
  void spine_curve_timeline_apply(
    spine_curve_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_curve_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_curve_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_curve_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_curve_timeline_apply');
  late final _spine_curve_timeline_apply = _spine_curve_timeline_applyPtr.asFunction<
      void Function(spine_curve_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_curve_timeline_get_frame_entries(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_curve_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_curve_timeline)>>('spine_curve_timeline_get_frame_entries');
  late final _spine_curve_timeline_get_frame_entries =
      _spine_curve_timeline_get_frame_entriesPtr.asFunction<int Function(spine_curve_timeline)>();

  int spine_curve_timeline_get_frame_count(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_curve_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_curve_timeline)>>('spine_curve_timeline_get_frame_count');
  late final _spine_curve_timeline_get_frame_count =
      _spine_curve_timeline_get_frame_countPtr.asFunction<int Function(spine_curve_timeline)>();

  spine_array_float spine_curve_timeline_get_frames(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_frames(
      self,
    );
  }

  late final _spine_curve_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_curve_timeline)>>('spine_curve_timeline_get_frames');
  late final _spine_curve_timeline_get_frames =
      _spine_curve_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_curve_timeline)>();

  double spine_curve_timeline_get_duration(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_duration(
      self,
    );
  }

  late final _spine_curve_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_curve_timeline)>>('spine_curve_timeline_get_duration');
  late final _spine_curve_timeline_get_duration =
      _spine_curve_timeline_get_durationPtr.asFunction<double Function(spine_curve_timeline)>();

  spine_array_property_id spine_curve_timeline_get_property_ids(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_curve_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_curve_timeline)>>(
          'spine_curve_timeline_get_property_ids');
  late final _spine_curve_timeline_get_property_ids =
      _spine_curve_timeline_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_curve_timeline)>();

  spine_rtti spine_curve_timeline_rtti() {
    return _spine_curve_timeline_rtti();
  }

  late final _spine_curve_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_curve_timeline_rtti');
  late final _spine_curve_timeline_rtti = _spine_curve_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_curve_timeline1_dispose(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_dispose(
      self,
    );
  }

  late final _spine_curve_timeline1_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_curve_timeline1)>>('spine_curve_timeline1_dispose');
  late final _spine_curve_timeline1_dispose =
      _spine_curve_timeline1_disposePtr.asFunction<void Function(spine_curve_timeline1)>();

  spine_rtti spine_curve_timeline1_get_rtti(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_rtti(
      self,
    );
  }

  late final _spine_curve_timeline1_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_curve_timeline1)>>('spine_curve_timeline1_get_rtti');
  late final _spine_curve_timeline1_get_rtti =
      _spine_curve_timeline1_get_rttiPtr.asFunction<spine_rtti Function(spine_curve_timeline1)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_curve_timeline1_set_frame(
    spine_curve_timeline1 self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_curve_timeline1_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_curve_timeline1_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_curve_timeline1, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_curve_timeline1_set_frame');
  late final _spine_curve_timeline1_set_frame =
      _spine_curve_timeline1_set_framePtr.asFunction<void Function(spine_curve_timeline1, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_curve_timeline1_get_curve_value(
    spine_curve_timeline1 self,
    double time,
  ) {
    return _spine_curve_timeline1_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_curve_timeline1_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_curve_timeline1, ffi.Float)>>(
          'spine_curve_timeline1_get_curve_value');
  late final _spine_curve_timeline1_get_curve_value =
      _spine_curve_timeline1_get_curve_valuePtr.asFunction<double Function(spine_curve_timeline1, double)>();

  double spine_curve_timeline1_get_relative_value(
    spine_curve_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_curve_timeline1_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_curve_timeline1_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_curve_timeline1, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_curve_timeline1_get_relative_value');
  late final _spine_curve_timeline1_get_relative_value = _spine_curve_timeline1_get_relative_valuePtr
      .asFunction<double Function(spine_curve_timeline1, double, double, int, double, double)>();

  double spine_curve_timeline1_get_absolute_value_1(
    spine_curve_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_curve_timeline1_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_curve_timeline1_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_curve_timeline1, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_curve_timeline1_get_absolute_value_1');
  late final _spine_curve_timeline1_get_absolute_value_1 = _spine_curve_timeline1_get_absolute_value_1Ptr
      .asFunction<double Function(spine_curve_timeline1, double, double, int, double, double)>();

  double spine_curve_timeline1_get_absolute_value_2(
    spine_curve_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_curve_timeline1_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_curve_timeline1_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_curve_timeline1, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_curve_timeline1_get_absolute_value_2');
  late final _spine_curve_timeline1_get_absolute_value_2 = _spine_curve_timeline1_get_absolute_value_2Ptr
      .asFunction<double Function(spine_curve_timeline1, double, double, int, double, double, double)>();

  double spine_curve_timeline1_get_scale_value(
    spine_curve_timeline1 self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_curve_timeline1_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_curve_timeline1_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_curve_timeline1, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_curve_timeline1_get_scale_value');
  late final _spine_curve_timeline1_get_scale_value = _spine_curve_timeline1_get_scale_valuePtr
      .asFunction<double Function(spine_curve_timeline1, double, double, int, int, double, double)>();

  void spine_curve_timeline1_set_linear(
    spine_curve_timeline1 self,
    int frame,
  ) {
    return _spine_curve_timeline1_set_linear(
      self,
      frame,
    );
  }

  late final _spine_curve_timeline1_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_curve_timeline1, ffi.Size)>>(
          'spine_curve_timeline1_set_linear');
  late final _spine_curve_timeline1_set_linear =
      _spine_curve_timeline1_set_linearPtr.asFunction<void Function(spine_curve_timeline1, int)>();

  void spine_curve_timeline1_set_stepped(
    spine_curve_timeline1 self,
    int frame,
  ) {
    return _spine_curve_timeline1_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_curve_timeline1_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_curve_timeline1, ffi.Size)>>(
          'spine_curve_timeline1_set_stepped');
  late final _spine_curve_timeline1_set_stepped =
      _spine_curve_timeline1_set_steppedPtr.asFunction<void Function(spine_curve_timeline1, int)>();

  void spine_curve_timeline1_set_bezier(
    spine_curve_timeline1 self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_curve_timeline1_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_curve_timeline1_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_curve_timeline1, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_curve_timeline1_set_bezier');
  late final _spine_curve_timeline1_set_bezier = _spine_curve_timeline1_set_bezierPtr.asFunction<
      void Function(
          spine_curve_timeline1, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_curve_timeline1_get_bezier_value(
    spine_curve_timeline1 self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_curve_timeline1_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_curve_timeline1_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_curve_timeline1, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_curve_timeline1_get_bezier_value');
  late final _spine_curve_timeline1_get_bezier_value = _spine_curve_timeline1_get_bezier_valuePtr
      .asFunction<double Function(spine_curve_timeline1, double, int, int, int)>();

  spine_array_float spine_curve_timeline1_get_curves(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_curves(
      self,
    );
  }

  late final _spine_curve_timeline1_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_get_curves');
  late final _spine_curve_timeline1_get_curves =
      _spine_curve_timeline1_get_curvesPtr.asFunction<spine_array_float Function(spine_curve_timeline1)>();

  /// Sets the value(s) for the specified time.
  ///
  /// @param skeleton The skeleton the timeline is being applied to. This provides access to the bones, slots, and other skeleton components the timeline may change.
  /// @param lastTime lastTime The time this timeline was last applied. Timelines such as EventTimeline trigger only at specific times rather than every frame. In that case, the timeline triggers everything between lastTime (exclusive) and time (inclusive).
  /// @param time The time within the animation. Most timelines find the key before and the key after this time so they can interpolate between the keys.
  /// @param events If any events are fired, they are added to this array. Can be NULL to ignore firing events or if the timeline does not fire events. May be NULL.
  /// @param alpha alpha 0 applies the current or setup pose value (depending on pose parameter). 1 applies the timeline value. Between 0 and 1 applies a value between the current or setup pose and the timeline value. By adjusting alpha over time, an animation can be mixed in or out. alpha can also be useful to apply animations on top of each other (layered).
  /// @param blend Controls how mixing is applied when alpha is than 1.
  /// @param direction Indicates whether the timeline is mixing in or out. Used by timelines which perform instant transitions such as DrawOrderTimeline and AttachmentTimeline.
  /// @param appliedPose True to modify the applied pose.
  void spine_curve_timeline1_apply(
    spine_curve_timeline1 self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_curve_timeline1_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_curve_timeline1_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_curve_timeline1, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_curve_timeline1_apply');
  late final _spine_curve_timeline1_apply = _spine_curve_timeline1_applyPtr.asFunction<
      void Function(
          spine_curve_timeline1, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_curve_timeline1_get_frame_entries(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_frame_entries(
      self,
    );
  }

  late final _spine_curve_timeline1_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_curve_timeline1)>>('spine_curve_timeline1_get_frame_entries');
  late final _spine_curve_timeline1_get_frame_entries =
      _spine_curve_timeline1_get_frame_entriesPtr.asFunction<int Function(spine_curve_timeline1)>();

  int spine_curve_timeline1_get_frame_count(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_frame_count(
      self,
    );
  }

  late final _spine_curve_timeline1_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_curve_timeline1)>>('spine_curve_timeline1_get_frame_count');
  late final _spine_curve_timeline1_get_frame_count =
      _spine_curve_timeline1_get_frame_countPtr.asFunction<int Function(spine_curve_timeline1)>();

  spine_array_float spine_curve_timeline1_get_frames(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_frames(
      self,
    );
  }

  late final _spine_curve_timeline1_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_get_frames');
  late final _spine_curve_timeline1_get_frames =
      _spine_curve_timeline1_get_framesPtr.asFunction<spine_array_float Function(spine_curve_timeline1)>();

  double spine_curve_timeline1_get_duration(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_duration(
      self,
    );
  }

  late final _spine_curve_timeline1_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_curve_timeline1)>>('spine_curve_timeline1_get_duration');
  late final _spine_curve_timeline1_get_duration =
      _spine_curve_timeline1_get_durationPtr.asFunction<double Function(spine_curve_timeline1)>();

  spine_array_property_id spine_curve_timeline1_get_property_ids(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_property_ids(
      self,
    );
  }

  late final _spine_curve_timeline1_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_get_property_ids');
  late final _spine_curve_timeline1_get_property_ids =
      _spine_curve_timeline1_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_curve_timeline1)>();

  spine_rtti spine_curve_timeline1_rtti() {
    return _spine_curve_timeline1_rtti();
  }

  late final _spine_curve_timeline1_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_curve_timeline1_rtti');
  late final _spine_curve_timeline1_rtti = _spine_curve_timeline1_rttiPtr.asFunction<spine_rtti Function()>();

  spine_deform_timeline spine_deform_timeline_create(
    int frameCount,
    int bezierCount,
    int slotIndex,
    spine_vertex_attachment attachment,
  ) {
    return _spine_deform_timeline_create(
      frameCount,
      bezierCount,
      slotIndex,
      attachment,
    );
  }

  late final _spine_deform_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_deform_timeline Function(ffi.Size, ffi.Size, ffi.Int, spine_vertex_attachment)>>(
          'spine_deform_timeline_create');
  late final _spine_deform_timeline_create = _spine_deform_timeline_createPtr
      .asFunction<spine_deform_timeline Function(int, int, int, spine_vertex_attachment)>();

  void spine_deform_timeline_dispose(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_dispose(
      self,
    );
  }

  late final _spine_deform_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_deform_timeline)>>('spine_deform_timeline_dispose');
  late final _spine_deform_timeline_dispose =
      _spine_deform_timeline_disposePtr.asFunction<void Function(spine_deform_timeline)>();

  spine_rtti spine_deform_timeline_get_rtti(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_rtti(
      self,
    );
  }

  late final _spine_deform_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_deform_timeline)>>('spine_deform_timeline_get_rtti');
  late final _spine_deform_timeline_get_rtti =
      _spine_deform_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_deform_timeline)>();

  /// Sets the time and vertices for the specified frame.
  void spine_deform_timeline_set_frame(
    spine_deform_timeline self,
    int frameIndex,
    double time,
    spine_array_float vertices,
  ) {
    return _spine_deform_timeline_set_frame(
      self,
      frameIndex,
      time,
      vertices,
    );
  }

  late final _spine_deform_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_deform_timeline, ffi.Int, ffi.Float, spine_array_float)>>(
          'spine_deform_timeline_set_frame');
  late final _spine_deform_timeline_set_frame = _spine_deform_timeline_set_framePtr
      .asFunction<void Function(spine_deform_timeline, int, double, spine_array_float)>();

  /// The attachment that will be deformed.
  spine_vertex_attachment spine_deform_timeline_get_attachment(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_attachment(
      self,
    );
  }

  late final _spine_deform_timeline_get_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_vertex_attachment Function(spine_deform_timeline)>>(
          'spine_deform_timeline_get_attachment');
  late final _spine_deform_timeline_get_attachment =
      _spine_deform_timeline_get_attachmentPtr.asFunction<spine_vertex_attachment Function(spine_deform_timeline)>();

  void spine_deform_timeline_set_attachment(
    spine_deform_timeline self,
    spine_vertex_attachment inValue,
  ) {
    return _spine_deform_timeline_set_attachment(
      self,
      inValue,
    );
  }

  late final _spine_deform_timeline_set_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_deform_timeline, spine_vertex_attachment)>>(
          'spine_deform_timeline_set_attachment');
  late final _spine_deform_timeline_set_attachment = _spine_deform_timeline_set_attachmentPtr
      .asFunction<void Function(spine_deform_timeline, spine_vertex_attachment)>();

  void spine_deform_timeline_set_bezier(
    spine_deform_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_deform_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_deform_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_deform_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_deform_timeline_set_bezier');
  late final _spine_deform_timeline_set_bezier = _spine_deform_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_deform_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_deform_timeline_get_curve_percent(
    spine_deform_timeline self,
    double time,
    int frame,
  ) {
    return _spine_deform_timeline_get_curve_percent(
      self,
      time,
      frame,
    );
  }

  late final _spine_deform_timeline_get_curve_percentPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_deform_timeline, ffi.Float, ffi.Int)>>(
          'spine_deform_timeline_get_curve_percent');
  late final _spine_deform_timeline_get_curve_percent =
      _spine_deform_timeline_get_curve_percentPtr.asFunction<double Function(spine_deform_timeline, double, int)>();

  int spine_deform_timeline_get_frame_count(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_deform_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_deform_timeline)>>('spine_deform_timeline_get_frame_count');
  late final _spine_deform_timeline_get_frame_count =
      _spine_deform_timeline_get_frame_countPtr.asFunction<int Function(spine_deform_timeline)>();

  void spine_deform_timeline_apply(
    spine_deform_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_deform_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_deform_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_deform_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_deform_timeline_apply');
  late final _spine_deform_timeline_apply = _spine_deform_timeline_applyPtr.asFunction<
      void Function(
          spine_deform_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_deform_timeline_get_slot_index(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_deform_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_deform_timeline)>>('spine_deform_timeline_get_slot_index');
  late final _spine_deform_timeline_get_slot_index =
      _spine_deform_timeline_get_slot_indexPtr.asFunction<int Function(spine_deform_timeline)>();

  void spine_deform_timeline_set_slot_index(
    spine_deform_timeline self,
    int inValue,
  ) {
    return _spine_deform_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_deform_timeline_set_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_deform_timeline, ffi.Int)>>(
          'spine_deform_timeline_set_slot_index');
  late final _spine_deform_timeline_set_slot_index =
      _spine_deform_timeline_set_slot_indexPtr.asFunction<void Function(spine_deform_timeline, int)>();

  void spine_deform_timeline_set_linear(
    spine_deform_timeline self,
    int frame,
  ) {
    return _spine_deform_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_deform_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_deform_timeline, ffi.Size)>>(
          'spine_deform_timeline_set_linear');
  late final _spine_deform_timeline_set_linear =
      _spine_deform_timeline_set_linearPtr.asFunction<void Function(spine_deform_timeline, int)>();

  void spine_deform_timeline_set_stepped(
    spine_deform_timeline self,
    int frame,
  ) {
    return _spine_deform_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_deform_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_deform_timeline, ffi.Size)>>(
          'spine_deform_timeline_set_stepped');
  late final _spine_deform_timeline_set_stepped =
      _spine_deform_timeline_set_steppedPtr.asFunction<void Function(spine_deform_timeline, int)>();

  double spine_deform_timeline_get_bezier_value(
    spine_deform_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_deform_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_deform_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_deform_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_deform_timeline_get_bezier_value');
  late final _spine_deform_timeline_get_bezier_value = _spine_deform_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_deform_timeline, double, int, int, int)>();

  spine_array_float spine_deform_timeline_get_curves(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_curves(
      self,
    );
  }

  late final _spine_deform_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_deform_timeline)>>(
          'spine_deform_timeline_get_curves');
  late final _spine_deform_timeline_get_curves =
      _spine_deform_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_deform_timeline)>();

  int spine_deform_timeline_get_frame_entries(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_deform_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_deform_timeline)>>('spine_deform_timeline_get_frame_entries');
  late final _spine_deform_timeline_get_frame_entries =
      _spine_deform_timeline_get_frame_entriesPtr.asFunction<int Function(spine_deform_timeline)>();

  spine_array_float spine_deform_timeline_get_frames(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_frames(
      self,
    );
  }

  late final _spine_deform_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_deform_timeline)>>(
          'spine_deform_timeline_get_frames');
  late final _spine_deform_timeline_get_frames =
      _spine_deform_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_deform_timeline)>();

  double spine_deform_timeline_get_duration(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_duration(
      self,
    );
  }

  late final _spine_deform_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_deform_timeline)>>('spine_deform_timeline_get_duration');
  late final _spine_deform_timeline_get_duration =
      _spine_deform_timeline_get_durationPtr.asFunction<double Function(spine_deform_timeline)>();

  spine_array_property_id spine_deform_timeline_get_property_ids(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_deform_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_deform_timeline)>>(
          'spine_deform_timeline_get_property_ids');
  late final _spine_deform_timeline_get_property_ids =
      _spine_deform_timeline_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_deform_timeline)>();

  spine_rtti spine_deform_timeline_rtti() {
    return _spine_deform_timeline_rtti();
  }

  late final _spine_deform_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_deform_timeline_rtti');
  late final _spine_deform_timeline_rtti = _spine_deform_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_draw_order_timeline spine_draw_order_timeline_create(
    int frameCount,
  ) {
    return _spine_draw_order_timeline_create(
      frameCount,
    );
  }

  late final _spine_draw_order_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_draw_order_timeline Function(ffi.Size)>>('spine_draw_order_timeline_create');
  late final _spine_draw_order_timeline_create =
      _spine_draw_order_timeline_createPtr.asFunction<spine_draw_order_timeline Function(int)>();

  void spine_draw_order_timeline_dispose(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_dispose(
      self,
    );
  }

  late final _spine_draw_order_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_draw_order_timeline)>>('spine_draw_order_timeline_dispose');
  late final _spine_draw_order_timeline_dispose =
      _spine_draw_order_timeline_disposePtr.asFunction<void Function(spine_draw_order_timeline)>();

  spine_rtti spine_draw_order_timeline_get_rtti(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_get_rtti(
      self,
    );
  }

  late final _spine_draw_order_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_draw_order_timeline)>>('spine_draw_order_timeline_get_rtti');
  late final _spine_draw_order_timeline_get_rtti =
      _spine_draw_order_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_draw_order_timeline)>();

  void spine_draw_order_timeline_apply(
    spine_draw_order_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_draw_order_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_draw_order_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_draw_order_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event,
              ffi.Float, ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_draw_order_timeline_apply');
  late final _spine_draw_order_timeline_apply = _spine_draw_order_timeline_applyPtr.asFunction<
      void Function(
          spine_draw_order_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_draw_order_timeline_get_frame_count(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_draw_order_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_draw_order_timeline)>>(
          'spine_draw_order_timeline_get_frame_count');
  late final _spine_draw_order_timeline_get_frame_count =
      _spine_draw_order_timeline_get_frame_countPtr.asFunction<int Function(spine_draw_order_timeline)>();

  /// Sets the time and draw order for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  /// @param drawOrder For each slot in Skeleton::slots, the index of the slot in the new draw order. May be null to use setup pose draw order.
  void spine_draw_order_timeline_set_frame(
    spine_draw_order_timeline self,
    int frame,
    double time,
    spine_array_int drawOrder,
  ) {
    return _spine_draw_order_timeline_set_frame(
      self,
      frame,
      time,
      drawOrder,
    );
  }

  late final _spine_draw_order_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_draw_order_timeline, ffi.Size, ffi.Float, spine_array_int)>>(
          'spine_draw_order_timeline_set_frame');
  late final _spine_draw_order_timeline_set_frame = _spine_draw_order_timeline_set_framePtr
      .asFunction<void Function(spine_draw_order_timeline, int, double, spine_array_int)>();

  int spine_draw_order_timeline_get_frame_entries(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_draw_order_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_draw_order_timeline)>>(
          'spine_draw_order_timeline_get_frame_entries');
  late final _spine_draw_order_timeline_get_frame_entries =
      _spine_draw_order_timeline_get_frame_entriesPtr.asFunction<int Function(spine_draw_order_timeline)>();

  spine_array_float spine_draw_order_timeline_get_frames(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_get_frames(
      self,
    );
  }

  late final _spine_draw_order_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_draw_order_timeline)>>(
          'spine_draw_order_timeline_get_frames');
  late final _spine_draw_order_timeline_get_frames =
      _spine_draw_order_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_draw_order_timeline)>();

  double spine_draw_order_timeline_get_duration(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_get_duration(
      self,
    );
  }

  late final _spine_draw_order_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_draw_order_timeline)>>(
          'spine_draw_order_timeline_get_duration');
  late final _spine_draw_order_timeline_get_duration =
      _spine_draw_order_timeline_get_durationPtr.asFunction<double Function(spine_draw_order_timeline)>();

  spine_array_property_id spine_draw_order_timeline_get_property_ids(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_draw_order_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_draw_order_timeline)>>(
          'spine_draw_order_timeline_get_property_ids');
  late final _spine_draw_order_timeline_get_property_ids = _spine_draw_order_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_draw_order_timeline)>();

  spine_rtti spine_draw_order_timeline_rtti() {
    return _spine_draw_order_timeline_rtti();
  }

  late final _spine_draw_order_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_draw_order_timeline_rtti');
  late final _spine_draw_order_timeline_rtti = _spine_draw_order_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_event spine_event_create(
    double time,
    spine_event_data data,
  ) {
    return _spine_event_create(
      time,
      data,
    );
  }

  late final _spine_event_createPtr =
      _lookup<ffi.NativeFunction<spine_event Function(ffi.Float, spine_event_data)>>('spine_event_create');
  late final _spine_event_create = _spine_event_createPtr.asFunction<spine_event Function(double, spine_event_data)>();

  void spine_event_dispose(
    spine_event self,
  ) {
    return _spine_event_dispose(
      self,
    );
  }

  late final _spine_event_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event)>>('spine_event_dispose');
  late final _spine_event_dispose = _spine_event_disposePtr.asFunction<void Function(spine_event)>();

  /// The event's setup pose data.
  spine_event_data spine_event_get_data(
    spine_event self,
  ) {
    return _spine_event_get_data(
      self,
    );
  }

  late final _spine_event_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_event_data Function(spine_event)>>('spine_event_get_data');
  late final _spine_event_get_data = _spine_event_get_dataPtr.asFunction<spine_event_data Function(spine_event)>();

  /// The animation time this event was keyed.
  double spine_event_get_time(
    spine_event self,
  ) {
    return _spine_event_get_time(
      self,
    );
  }

  late final _spine_event_get_timePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>('spine_event_get_time');
  late final _spine_event_get_time = _spine_event_get_timePtr.asFunction<double Function(spine_event)>();

  int spine_event_get_int(
    spine_event self,
  ) {
    return _spine_event_get_int(
      self,
    );
  }

  late final _spine_event_get_intPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_event)>>('spine_event_get_int');
  late final _spine_event_get_int = _spine_event_get_intPtr.asFunction<int Function(spine_event)>();

  void spine_event_set_int(
    spine_event self,
    int inValue,
  ) {
    return _spine_event_set_int(
      self,
      inValue,
    );
  }

  late final _spine_event_set_intPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Int)>>('spine_event_set_int');
  late final _spine_event_set_int = _spine_event_set_intPtr.asFunction<void Function(spine_event, int)>();

  double spine_event_get_float(
    spine_event self,
  ) {
    return _spine_event_get_float(
      self,
    );
  }

  late final _spine_event_get_floatPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>('spine_event_get_float');
  late final _spine_event_get_float = _spine_event_get_floatPtr.asFunction<double Function(spine_event)>();

  void spine_event_set_float(
    spine_event self,
    double inValue,
  ) {
    return _spine_event_set_float(
      self,
      inValue,
    );
  }

  late final _spine_event_set_floatPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Float)>>('spine_event_set_float');
  late final _spine_event_set_float = _spine_event_set_floatPtr.asFunction<void Function(spine_event, double)>();

  ffi.Pointer<ffi.Char> spine_event_get_string(
    spine_event self,
  ) {
    return _spine_event_get_string(
      self,
    );
  }

  late final _spine_event_get_stringPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_event)>>('spine_event_get_string');
  late final _spine_event_get_string =
      _spine_event_get_stringPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_event)>();

  void spine_event_set_string(
    spine_event self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_event_set_string(
      self,
      inValue,
    );
  }

  late final _spine_event_set_stringPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Pointer<ffi.Char>)>>('spine_event_set_string');
  late final _spine_event_set_string =
      _spine_event_set_stringPtr.asFunction<void Function(spine_event, ffi.Pointer<ffi.Char>)>();

  double spine_event_get_volume(
    spine_event self,
  ) {
    return _spine_event_get_volume(
      self,
    );
  }

  late final _spine_event_get_volumePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>('spine_event_get_volume');
  late final _spine_event_get_volume = _spine_event_get_volumePtr.asFunction<double Function(spine_event)>();

  void spine_event_set_volume(
    spine_event self,
    double inValue,
  ) {
    return _spine_event_set_volume(
      self,
      inValue,
    );
  }

  late final _spine_event_set_volumePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Float)>>('spine_event_set_volume');
  late final _spine_event_set_volume = _spine_event_set_volumePtr.asFunction<void Function(spine_event, double)>();

  double spine_event_get_balance(
    spine_event self,
  ) {
    return _spine_event_get_balance(
      self,
    );
  }

  late final _spine_event_get_balancePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>('spine_event_get_balance');
  late final _spine_event_get_balance = _spine_event_get_balancePtr.asFunction<double Function(spine_event)>();

  void spine_event_set_balance(
    spine_event self,
    double inValue,
  ) {
    return _spine_event_set_balance(
      self,
      inValue,
    );
  }

  late final _spine_event_set_balancePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Float)>>('spine_event_set_balance');
  late final _spine_event_set_balance = _spine_event_set_balancePtr.asFunction<void Function(spine_event, double)>();

  spine_event_data spine_event_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_event_data_create(
      name,
    );
  }

  late final _spine_event_data_createPtr =
      _lookup<ffi.NativeFunction<spine_event_data Function(ffi.Pointer<ffi.Char>)>>('spine_event_data_create');
  late final _spine_event_data_create =
      _spine_event_data_createPtr.asFunction<spine_event_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_event_data_dispose(
    spine_event_data self,
  ) {
    return _spine_event_data_dispose(
      self,
    );
  }

  late final _spine_event_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data)>>('spine_event_data_dispose');
  late final _spine_event_data_dispose = _spine_event_data_disposePtr.asFunction<void Function(spine_event_data)>();

  /// The name of the event, which is unique within the skeleton.
  ffi.Pointer<ffi.Char> spine_event_data_get_name(
    spine_event_data self,
  ) {
    return _spine_event_data_get_name(
      self,
    );
  }

  late final _spine_event_data_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_event_data)>>('spine_event_data_get_name');
  late final _spine_event_data_get_name =
      _spine_event_data_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_event_data)>();

  int spine_event_data_get_int(
    spine_event_data self,
  ) {
    return _spine_event_data_get_int(
      self,
    );
  }

  late final _spine_event_data_get_intPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_event_data)>>('spine_event_data_get_int');
  late final _spine_event_data_get_int = _spine_event_data_get_intPtr.asFunction<int Function(spine_event_data)>();

  void spine_event_data_set_int(
    spine_event_data self,
    int inValue,
  ) {
    return _spine_event_data_set_int(
      self,
      inValue,
    );
  }

  late final _spine_event_data_set_intPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Int)>>('spine_event_data_set_int');
  late final _spine_event_data_set_int =
      _spine_event_data_set_intPtr.asFunction<void Function(spine_event_data, int)>();

  double spine_event_data_get_float(
    spine_event_data self,
  ) {
    return _spine_event_data_get_float(
      self,
    );
  }

  late final _spine_event_data_get_floatPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event_data)>>('spine_event_data_get_float');
  late final _spine_event_data_get_float =
      _spine_event_data_get_floatPtr.asFunction<double Function(spine_event_data)>();

  void spine_event_data_set_float(
    spine_event_data self,
    double inValue,
  ) {
    return _spine_event_data_set_float(
      self,
      inValue,
    );
  }

  late final _spine_event_data_set_floatPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Float)>>('spine_event_data_set_float');
  late final _spine_event_data_set_float =
      _spine_event_data_set_floatPtr.asFunction<void Function(spine_event_data, double)>();

  ffi.Pointer<ffi.Char> spine_event_data_get_string(
    spine_event_data self,
  ) {
    return _spine_event_data_get_string(
      self,
    );
  }

  late final _spine_event_data_get_stringPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_event_data)>>('spine_event_data_get_string');
  late final _spine_event_data_get_string =
      _spine_event_data_get_stringPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_event_data)>();

  void spine_event_data_set_string(
    spine_event_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_event_data_set_string(
      self,
      inValue,
    );
  }

  late final _spine_event_data_set_stringPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Pointer<ffi.Char>)>>(
          'spine_event_data_set_string');
  late final _spine_event_data_set_string =
      _spine_event_data_set_stringPtr.asFunction<void Function(spine_event_data, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> spine_event_data_get_audio_path(
    spine_event_data self,
  ) {
    return _spine_event_data_get_audio_path(
      self,
    );
  }

  late final _spine_event_data_get_audio_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_event_data)>>('spine_event_data_get_audio_path');
  late final _spine_event_data_get_audio_path =
      _spine_event_data_get_audio_pathPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_event_data)>();

  void spine_event_data_set_audio_path(
    spine_event_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_event_data_set_audio_path(
      self,
      inValue,
    );
  }

  late final _spine_event_data_set_audio_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Pointer<ffi.Char>)>>(
          'spine_event_data_set_audio_path');
  late final _spine_event_data_set_audio_path =
      _spine_event_data_set_audio_pathPtr.asFunction<void Function(spine_event_data, ffi.Pointer<ffi.Char>)>();

  double spine_event_data_get_volume(
    spine_event_data self,
  ) {
    return _spine_event_data_get_volume(
      self,
    );
  }

  late final _spine_event_data_get_volumePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event_data)>>('spine_event_data_get_volume');
  late final _spine_event_data_get_volume =
      _spine_event_data_get_volumePtr.asFunction<double Function(spine_event_data)>();

  void spine_event_data_set_volume(
    spine_event_data self,
    double inValue,
  ) {
    return _spine_event_data_set_volume(
      self,
      inValue,
    );
  }

  late final _spine_event_data_set_volumePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Float)>>('spine_event_data_set_volume');
  late final _spine_event_data_set_volume =
      _spine_event_data_set_volumePtr.asFunction<void Function(spine_event_data, double)>();

  double spine_event_data_get_balance(
    spine_event_data self,
  ) {
    return _spine_event_data_get_balance(
      self,
    );
  }

  late final _spine_event_data_get_balancePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event_data)>>('spine_event_data_get_balance');
  late final _spine_event_data_get_balance =
      _spine_event_data_get_balancePtr.asFunction<double Function(spine_event_data)>();

  void spine_event_data_set_balance(
    spine_event_data self,
    double inValue,
  ) {
    return _spine_event_data_set_balance(
      self,
      inValue,
    );
  }

  late final _spine_event_data_set_balancePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Float)>>('spine_event_data_set_balance');
  late final _spine_event_data_set_balance =
      _spine_event_data_set_balancePtr.asFunction<void Function(spine_event_data, double)>();

  spine_event_queue_entry spine_event_queue_entry_create(
    int eventType,
    spine_track_entry trackEntry,
    spine_event event,
  ) {
    return _spine_event_queue_entry_create(
      eventType,
      trackEntry,
      event,
    );
  }

  late final _spine_event_queue_entry_createPtr =
      _lookup<ffi.NativeFunction<spine_event_queue_entry Function(ffi.Int32, spine_track_entry, spine_event)>>(
          'spine_event_queue_entry_create');
  late final _spine_event_queue_entry_create = _spine_event_queue_entry_createPtr
      .asFunction<spine_event_queue_entry Function(int, spine_track_entry, spine_event)>();

  void spine_event_queue_entry_dispose(
    spine_event_queue_entry self,
  ) {
    return _spine_event_queue_entry_dispose(
      self,
    );
  }

  late final _spine_event_queue_entry_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_queue_entry)>>('spine_event_queue_entry_dispose');
  late final _spine_event_queue_entry_dispose =
      _spine_event_queue_entry_disposePtr.asFunction<void Function(spine_event_queue_entry)>();

  int spine_event_queue_entry_get__type(
    spine_event_queue_entry self,
  ) {
    return _spine_event_queue_entry_get__type(
      self,
    );
  }

  late final _spine_event_queue_entry_get__typePtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_event_queue_entry)>>('spine_event_queue_entry_get__type');
  late final _spine_event_queue_entry_get__type =
      _spine_event_queue_entry_get__typePtr.asFunction<int Function(spine_event_queue_entry)>();

  void spine_event_queue_entry_set__type(
    spine_event_queue_entry self,
    int value,
  ) {
    return _spine_event_queue_entry_set__type(
      self,
      value,
    );
  }

  late final _spine_event_queue_entry_set__typePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_queue_entry, ffi.Int32)>>(
          'spine_event_queue_entry_set__type');
  late final _spine_event_queue_entry_set__type =
      _spine_event_queue_entry_set__typePtr.asFunction<void Function(spine_event_queue_entry, int)>();

  spine_track_entry spine_event_queue_entry_get__entry(
    spine_event_queue_entry self,
  ) {
    return _spine_event_queue_entry_get__entry(
      self,
    );
  }

  late final _spine_event_queue_entry_get__entryPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function(spine_event_queue_entry)>>(
          'spine_event_queue_entry_get__entry');
  late final _spine_event_queue_entry_get__entry =
      _spine_event_queue_entry_get__entryPtr.asFunction<spine_track_entry Function(spine_event_queue_entry)>();

  void spine_event_queue_entry_set__entry(
    spine_event_queue_entry self,
    spine_track_entry value,
  ) {
    return _spine_event_queue_entry_set__entry(
      self,
      value,
    );
  }

  late final _spine_event_queue_entry_set__entryPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_queue_entry, spine_track_entry)>>(
          'spine_event_queue_entry_set__entry');
  late final _spine_event_queue_entry_set__entry =
      _spine_event_queue_entry_set__entryPtr.asFunction<void Function(spine_event_queue_entry, spine_track_entry)>();

  spine_event spine_event_queue_entry_get__event(
    spine_event_queue_entry self,
  ) {
    return _spine_event_queue_entry_get__event(
      self,
    );
  }

  late final _spine_event_queue_entry_get__eventPtr =
      _lookup<ffi.NativeFunction<spine_event Function(spine_event_queue_entry)>>('spine_event_queue_entry_get__event');
  late final _spine_event_queue_entry_get__event =
      _spine_event_queue_entry_get__eventPtr.asFunction<spine_event Function(spine_event_queue_entry)>();

  void spine_event_queue_entry_set__event(
    spine_event_queue_entry self,
    spine_event value,
  ) {
    return _spine_event_queue_entry_set__event(
      self,
      value,
    );
  }

  late final _spine_event_queue_entry_set__eventPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_queue_entry, spine_event)>>(
          'spine_event_queue_entry_set__event');
  late final _spine_event_queue_entry_set__event =
      _spine_event_queue_entry_set__eventPtr.asFunction<void Function(spine_event_queue_entry, spine_event)>();

  spine_event_timeline spine_event_timeline_create(
    int frameCount,
  ) {
    return _spine_event_timeline_create(
      frameCount,
    );
  }

  late final _spine_event_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_event_timeline Function(ffi.Size)>>('spine_event_timeline_create');
  late final _spine_event_timeline_create =
      _spine_event_timeline_createPtr.asFunction<spine_event_timeline Function(int)>();

  void spine_event_timeline_dispose(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_dispose(
      self,
    );
  }

  late final _spine_event_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_timeline)>>('spine_event_timeline_dispose');
  late final _spine_event_timeline_dispose =
      _spine_event_timeline_disposePtr.asFunction<void Function(spine_event_timeline)>();

  spine_rtti spine_event_timeline_get_rtti(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_rtti(
      self,
    );
  }

  late final _spine_event_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_event_timeline)>>('spine_event_timeline_get_rtti');
  late final _spine_event_timeline_get_rtti =
      _spine_event_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_event_timeline)>();

  /// Fires events for frames > lastTime and < = time.
  void spine_event_timeline_apply(
    spine_event_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_event_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_event_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_event_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_event_timeline_apply');
  late final _spine_event_timeline_apply = _spine_event_timeline_applyPtr.asFunction<
      void Function(spine_event_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_event_timeline_get_frame_count(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_event_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_event_timeline)>>('spine_event_timeline_get_frame_count');
  late final _spine_event_timeline_get_frame_count =
      _spine_event_timeline_get_frame_countPtr.asFunction<int Function(spine_event_timeline)>();

  /// The event for each frame.
  spine_array_event spine_event_timeline_get_events(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_events(
      self,
    );
  }

  late final _spine_event_timeline_get_eventsPtr =
      _lookup<ffi.NativeFunction<spine_array_event Function(spine_event_timeline)>>('spine_event_timeline_get_events');
  late final _spine_event_timeline_get_events =
      _spine_event_timeline_get_eventsPtr.asFunction<spine_array_event Function(spine_event_timeline)>();

  /// Sets the time and event for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  void spine_event_timeline_set_frame(
    spine_event_timeline self,
    int frame,
    spine_event event,
  ) {
    return _spine_event_timeline_set_frame(
      self,
      frame,
      event,
    );
  }

  late final _spine_event_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_timeline, ffi.Size, spine_event)>>(
          'spine_event_timeline_set_frame');
  late final _spine_event_timeline_set_frame =
      _spine_event_timeline_set_framePtr.asFunction<void Function(spine_event_timeline, int, spine_event)>();

  int spine_event_timeline_get_frame_entries(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_event_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_event_timeline)>>('spine_event_timeline_get_frame_entries');
  late final _spine_event_timeline_get_frame_entries =
      _spine_event_timeline_get_frame_entriesPtr.asFunction<int Function(spine_event_timeline)>();

  spine_array_float spine_event_timeline_get_frames(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_frames(
      self,
    );
  }

  late final _spine_event_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_event_timeline)>>('spine_event_timeline_get_frames');
  late final _spine_event_timeline_get_frames =
      _spine_event_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_event_timeline)>();

  double spine_event_timeline_get_duration(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_duration(
      self,
    );
  }

  late final _spine_event_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event_timeline)>>('spine_event_timeline_get_duration');
  late final _spine_event_timeline_get_duration =
      _spine_event_timeline_get_durationPtr.asFunction<double Function(spine_event_timeline)>();

  spine_array_property_id spine_event_timeline_get_property_ids(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_event_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_event_timeline)>>(
          'spine_event_timeline_get_property_ids');
  late final _spine_event_timeline_get_property_ids =
      _spine_event_timeline_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_event_timeline)>();

  spine_rtti spine_event_timeline_rtti() {
    return _spine_event_timeline_rtti();
  }

  late final _spine_event_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_event_timeline_rtti');
  late final _spine_event_timeline_rtti = _spine_event_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_from_property_dispose(
    spine_from_property self,
  ) {
    return _spine_from_property_dispose(
      self,
    );
  }

  late final _spine_from_property_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_property)>>('spine_from_property_dispose');
  late final _spine_from_property_dispose =
      _spine_from_property_disposePtr.asFunction<void Function(spine_from_property)>();

  spine_rtti spine_from_property_get_rtti(
    spine_from_property self,
  ) {
    return _spine_from_property_get_rtti(
      self,
    );
  }

  late final _spine_from_property_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_property)>>('spine_from_property_get_rtti');
  late final _spine_from_property_get_rtti =
      _spine_from_property_get_rttiPtr.asFunction<spine_rtti Function(spine_from_property)>();

  /// Reads this property from the specified bone.
  double spine_from_property_value(
    spine_from_property self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_property_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_property_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_from_property, spine_skeleton, spine_bone_pose, ffi.Bool,
              ffi.Pointer<ffi.Float>)>>('spine_from_property_value');
  late final _spine_from_property_value = _spine_from_property_valuePtr.asFunction<
      double Function(spine_from_property, spine_skeleton, spine_bone_pose, bool, ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_property_rtti() {
    return _spine_from_property_rtti();
  }

  late final _spine_from_property_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_from_property_rtti');
  late final _spine_from_property_rtti = _spine_from_property_rttiPtr.asFunction<spine_rtti Function()>();

  double spine_from_property_get__offset(
    spine_from_property self,
  ) {
    return _spine_from_property_get__offset(
      self,
    );
  }

  late final _spine_from_property_get__offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_from_property)>>('spine_from_property_get__offset');
  late final _spine_from_property_get__offset =
      _spine_from_property_get__offsetPtr.asFunction<double Function(spine_from_property)>();

  void spine_from_property_set__offset(
    spine_from_property self,
    double value,
  ) {
    return _spine_from_property_set__offset(
      self,
      value,
    );
  }

  late final _spine_from_property_set__offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_property, ffi.Float)>>('spine_from_property_set__offset');
  late final _spine_from_property_set__offset =
      _spine_from_property_set__offsetPtr.asFunction<void Function(spine_from_property, double)>();

  spine_array_to_property spine_from_property_get__to(
    spine_from_property self,
  ) {
    return _spine_from_property_get__to(
      self,
    );
  }

  late final _spine_from_property_get__toPtr =
      _lookup<ffi.NativeFunction<spine_array_to_property Function(spine_from_property)>>('spine_from_property_get__to');
  late final _spine_from_property_get__to =
      _spine_from_property_get__toPtr.asFunction<spine_array_to_property Function(spine_from_property)>();

  void spine_from_property_set__to(
    spine_from_property self,
    spine_array_to_property value,
  ) {
    return _spine_from_property_set__to(
      self,
      value,
    );
  }

  late final _spine_from_property_set__toPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_property, spine_array_to_property)>>(
          'spine_from_property_set__to');
  late final _spine_from_property_set__to =
      _spine_from_property_set__toPtr.asFunction<void Function(spine_from_property, spine_array_to_property)>();

  spine_from_rotate spine_from_rotate_create() {
    return _spine_from_rotate_create();
  }

  late final _spine_from_rotate_createPtr =
      _lookup<ffi.NativeFunction<spine_from_rotate Function()>>('spine_from_rotate_create');
  late final _spine_from_rotate_create = _spine_from_rotate_createPtr.asFunction<spine_from_rotate Function()>();

  void spine_from_rotate_dispose(
    spine_from_rotate self,
  ) {
    return _spine_from_rotate_dispose(
      self,
    );
  }

  late final _spine_from_rotate_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_rotate)>>('spine_from_rotate_dispose');
  late final _spine_from_rotate_dispose = _spine_from_rotate_disposePtr.asFunction<void Function(spine_from_rotate)>();

  spine_rtti spine_from_rotate_get_rtti(
    spine_from_rotate self,
  ) {
    return _spine_from_rotate_get_rtti(
      self,
    );
  }

  late final _spine_from_rotate_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_rotate)>>('spine_from_rotate_get_rtti');
  late final _spine_from_rotate_get_rtti =
      _spine_from_rotate_get_rttiPtr.asFunction<spine_rtti Function(spine_from_rotate)>();

  double spine_from_rotate_value(
    spine_from_rotate self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_rotate_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_rotate_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_from_rotate, spine_skeleton, spine_bone_pose, ffi.Bool,
              ffi.Pointer<ffi.Float>)>>('spine_from_rotate_value');
  late final _spine_from_rotate_value = _spine_from_rotate_valuePtr
      .asFunction<double Function(spine_from_rotate, spine_skeleton, spine_bone_pose, bool, ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_rotate_rtti() {
    return _spine_from_rotate_rtti();
  }

  late final _spine_from_rotate_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_from_rotate_rtti');
  late final _spine_from_rotate_rtti = _spine_from_rotate_rttiPtr.asFunction<spine_rtti Function()>();

  spine_from_scale_x spine_from_scale_x_create() {
    return _spine_from_scale_x_create();
  }

  late final _spine_from_scale_x_createPtr =
      _lookup<ffi.NativeFunction<spine_from_scale_x Function()>>('spine_from_scale_x_create');
  late final _spine_from_scale_x_create = _spine_from_scale_x_createPtr.asFunction<spine_from_scale_x Function()>();

  void spine_from_scale_x_dispose(
    spine_from_scale_x self,
  ) {
    return _spine_from_scale_x_dispose(
      self,
    );
  }

  late final _spine_from_scale_x_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_scale_x)>>('spine_from_scale_x_dispose');
  late final _spine_from_scale_x_dispose =
      _spine_from_scale_x_disposePtr.asFunction<void Function(spine_from_scale_x)>();

  spine_rtti spine_from_scale_x_get_rtti(
    spine_from_scale_x self,
  ) {
    return _spine_from_scale_x_get_rtti(
      self,
    );
  }

  late final _spine_from_scale_x_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_scale_x)>>('spine_from_scale_x_get_rtti');
  late final _spine_from_scale_x_get_rtti =
      _spine_from_scale_x_get_rttiPtr.asFunction<spine_rtti Function(spine_from_scale_x)>();

  double spine_from_scale_x_value(
    spine_from_scale_x self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_scale_x_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_scale_x_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_from_scale_x, spine_skeleton, spine_bone_pose, ffi.Bool,
              ffi.Pointer<ffi.Float>)>>('spine_from_scale_x_value');
  late final _spine_from_scale_x_value = _spine_from_scale_x_valuePtr
      .asFunction<double Function(spine_from_scale_x, spine_skeleton, spine_bone_pose, bool, ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_scale_x_rtti() {
    return _spine_from_scale_x_rtti();
  }

  late final _spine_from_scale_x_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_from_scale_x_rtti');
  late final _spine_from_scale_x_rtti = _spine_from_scale_x_rttiPtr.asFunction<spine_rtti Function()>();

  spine_from_scale_y spine_from_scale_y_create() {
    return _spine_from_scale_y_create();
  }

  late final _spine_from_scale_y_createPtr =
      _lookup<ffi.NativeFunction<spine_from_scale_y Function()>>('spine_from_scale_y_create');
  late final _spine_from_scale_y_create = _spine_from_scale_y_createPtr.asFunction<spine_from_scale_y Function()>();

  void spine_from_scale_y_dispose(
    spine_from_scale_y self,
  ) {
    return _spine_from_scale_y_dispose(
      self,
    );
  }

  late final _spine_from_scale_y_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_scale_y)>>('spine_from_scale_y_dispose');
  late final _spine_from_scale_y_dispose =
      _spine_from_scale_y_disposePtr.asFunction<void Function(spine_from_scale_y)>();

  spine_rtti spine_from_scale_y_get_rtti(
    spine_from_scale_y self,
  ) {
    return _spine_from_scale_y_get_rtti(
      self,
    );
  }

  late final _spine_from_scale_y_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_scale_y)>>('spine_from_scale_y_get_rtti');
  late final _spine_from_scale_y_get_rtti =
      _spine_from_scale_y_get_rttiPtr.asFunction<spine_rtti Function(spine_from_scale_y)>();

  double spine_from_scale_y_value(
    spine_from_scale_y self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_scale_y_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_scale_y_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_from_scale_y, spine_skeleton, spine_bone_pose, ffi.Bool,
              ffi.Pointer<ffi.Float>)>>('spine_from_scale_y_value');
  late final _spine_from_scale_y_value = _spine_from_scale_y_valuePtr
      .asFunction<double Function(spine_from_scale_y, spine_skeleton, spine_bone_pose, bool, ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_scale_y_rtti() {
    return _spine_from_scale_y_rtti();
  }

  late final _spine_from_scale_y_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_from_scale_y_rtti');
  late final _spine_from_scale_y_rtti = _spine_from_scale_y_rttiPtr.asFunction<spine_rtti Function()>();

  spine_from_shear_y spine_from_shear_y_create() {
    return _spine_from_shear_y_create();
  }

  late final _spine_from_shear_y_createPtr =
      _lookup<ffi.NativeFunction<spine_from_shear_y Function()>>('spine_from_shear_y_create');
  late final _spine_from_shear_y_create = _spine_from_shear_y_createPtr.asFunction<spine_from_shear_y Function()>();

  void spine_from_shear_y_dispose(
    spine_from_shear_y self,
  ) {
    return _spine_from_shear_y_dispose(
      self,
    );
  }

  late final _spine_from_shear_y_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_shear_y)>>('spine_from_shear_y_dispose');
  late final _spine_from_shear_y_dispose =
      _spine_from_shear_y_disposePtr.asFunction<void Function(spine_from_shear_y)>();

  spine_rtti spine_from_shear_y_get_rtti(
    spine_from_shear_y self,
  ) {
    return _spine_from_shear_y_get_rtti(
      self,
    );
  }

  late final _spine_from_shear_y_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_shear_y)>>('spine_from_shear_y_get_rtti');
  late final _spine_from_shear_y_get_rtti =
      _spine_from_shear_y_get_rttiPtr.asFunction<spine_rtti Function(spine_from_shear_y)>();

  double spine_from_shear_y_value(
    spine_from_shear_y self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_shear_y_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_shear_y_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_from_shear_y, spine_skeleton, spine_bone_pose, ffi.Bool,
              ffi.Pointer<ffi.Float>)>>('spine_from_shear_y_value');
  late final _spine_from_shear_y_value = _spine_from_shear_y_valuePtr
      .asFunction<double Function(spine_from_shear_y, spine_skeleton, spine_bone_pose, bool, ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_shear_y_rtti() {
    return _spine_from_shear_y_rtti();
  }

  late final _spine_from_shear_y_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_from_shear_y_rtti');
  late final _spine_from_shear_y_rtti = _spine_from_shear_y_rttiPtr.asFunction<spine_rtti Function()>();

  spine_from_x spine_from_x_create() {
    return _spine_from_x_create();
  }

  late final _spine_from_x_createPtr = _lookup<ffi.NativeFunction<spine_from_x Function()>>('spine_from_x_create');
  late final _spine_from_x_create = _spine_from_x_createPtr.asFunction<spine_from_x Function()>();

  void spine_from_x_dispose(
    spine_from_x self,
  ) {
    return _spine_from_x_dispose(
      self,
    );
  }

  late final _spine_from_x_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_x)>>('spine_from_x_dispose');
  late final _spine_from_x_dispose = _spine_from_x_disposePtr.asFunction<void Function(spine_from_x)>();

  spine_rtti spine_from_x_get_rtti(
    spine_from_x self,
  ) {
    return _spine_from_x_get_rtti(
      self,
    );
  }

  late final _spine_from_x_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_x)>>('spine_from_x_get_rtti');
  late final _spine_from_x_get_rtti = _spine_from_x_get_rttiPtr.asFunction<spine_rtti Function(spine_from_x)>();

  double spine_from_x_value(
    spine_from_x self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_x_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_x_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_from_x, spine_skeleton, spine_bone_pose, ffi.Bool, ffi.Pointer<ffi.Float>)>>('spine_from_x_value');
  late final _spine_from_x_value = _spine_from_x_valuePtr
      .asFunction<double Function(spine_from_x, spine_skeleton, spine_bone_pose, bool, ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_x_rtti() {
    return _spine_from_x_rtti();
  }

  late final _spine_from_x_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_from_x_rtti');
  late final _spine_from_x_rtti = _spine_from_x_rttiPtr.asFunction<spine_rtti Function()>();

  spine_from_y spine_from_y_create() {
    return _spine_from_y_create();
  }

  late final _spine_from_y_createPtr = _lookup<ffi.NativeFunction<spine_from_y Function()>>('spine_from_y_create');
  late final _spine_from_y_create = _spine_from_y_createPtr.asFunction<spine_from_y Function()>();

  void spine_from_y_dispose(
    spine_from_y self,
  ) {
    return _spine_from_y_dispose(
      self,
    );
  }

  late final _spine_from_y_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_y)>>('spine_from_y_dispose');
  late final _spine_from_y_dispose = _spine_from_y_disposePtr.asFunction<void Function(spine_from_y)>();

  spine_rtti spine_from_y_get_rtti(
    spine_from_y self,
  ) {
    return _spine_from_y_get_rtti(
      self,
    );
  }

  late final _spine_from_y_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_y)>>('spine_from_y_get_rtti');
  late final _spine_from_y_get_rtti = _spine_from_y_get_rttiPtr.asFunction<spine_rtti Function(spine_from_y)>();

  double spine_from_y_value(
    spine_from_y self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_y_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_y_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_from_y, spine_skeleton, spine_bone_pose, ffi.Bool, ffi.Pointer<ffi.Float>)>>('spine_from_y_value');
  late final _spine_from_y_value = _spine_from_y_valuePtr
      .asFunction<double Function(spine_from_y, spine_skeleton, spine_bone_pose, bool, ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_y_rtti() {
    return _spine_from_y_rtti();
  }

  late final _spine_from_y_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_from_y_rtti');
  late final _spine_from_y_rtti = _spine_from_y_rttiPtr.asFunction<spine_rtti Function()>();

  spine_ik_constraint spine_ik_constraint_create(
    spine_ik_constraint_data data,
    spine_skeleton skeleton,
  ) {
    return _spine_ik_constraint_create(
      data,
      skeleton,
    );
  }

  late final _spine_ik_constraint_createPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint Function(spine_ik_constraint_data, spine_skeleton)>>(
          'spine_ik_constraint_create');
  late final _spine_ik_constraint_create = _spine_ik_constraint_createPtr
      .asFunction<spine_ik_constraint Function(spine_ik_constraint_data, spine_skeleton)>();

  void spine_ik_constraint_dispose(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_dispose(
      self,
    );
  }

  late final _spine_ik_constraint_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint)>>('spine_ik_constraint_dispose');
  late final _spine_ik_constraint_dispose =
      _spine_ik_constraint_disposePtr.asFunction<void Function(spine_ik_constraint)>();

  spine_rtti spine_ik_constraint_get_rtti(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_get_rtti(
      self,
    );
  }

  late final _spine_ik_constraint_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_ik_constraint)>>('spine_ik_constraint_get_rtti');
  late final _spine_ik_constraint_get_rtti =
      _spine_ik_constraint_get_rttiPtr.asFunction<spine_rtti Function(spine_ik_constraint)>();

  spine_ik_constraint spine_ik_constraint_copy(
    spine_ik_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_ik_constraint_copy(
      self,
      skeleton,
    );
  }

  late final _spine_ik_constraint_copyPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint Function(spine_ik_constraint, spine_skeleton)>>(
          'spine_ik_constraint_copy');
  late final _spine_ik_constraint_copy =
      _spine_ik_constraint_copyPtr.asFunction<spine_ik_constraint Function(spine_ik_constraint, spine_skeleton)>();

  void spine_ik_constraint_update(
    spine_ik_constraint self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_ik_constraint_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_ik_constraint_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, spine_skeleton, ffi.Int32)>>(
          'spine_ik_constraint_update');
  late final _spine_ik_constraint_update =
      _spine_ik_constraint_updatePtr.asFunction<void Function(spine_ik_constraint, spine_skeleton, int)>();

  void spine_ik_constraint_sort(
    spine_ik_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_ik_constraint_sort(
      self,
      skeleton,
    );
  }

  late final _spine_ik_constraint_sortPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, spine_skeleton)>>('spine_ik_constraint_sort');
  late final _spine_ik_constraint_sort =
      _spine_ik_constraint_sortPtr.asFunction<void Function(spine_ik_constraint, spine_skeleton)>();

  bool spine_ik_constraint_is_source_active(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_is_source_active(
      self,
    );
  }

  late final _spine_ik_constraint_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint)>>('spine_ik_constraint_is_source_active');
  late final _spine_ik_constraint_is_source_active =
      _spine_ik_constraint_is_source_activePtr.asFunction<bool Function(spine_ik_constraint)>();

  spine_array_bone_pose spine_ik_constraint_get_bones(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_get_bones(
      self,
    );
  }

  late final _spine_ik_constraint_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_bone_pose Function(spine_ik_constraint)>>('spine_ik_constraint_get_bones');
  late final _spine_ik_constraint_get_bones =
      _spine_ik_constraint_get_bonesPtr.asFunction<spine_array_bone_pose Function(spine_ik_constraint)>();

  spine_bone spine_ik_constraint_get_target(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_get_target(
      self,
    );
  }

  late final _spine_ik_constraint_get_targetPtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_ik_constraint)>>('spine_ik_constraint_get_target');
  late final _spine_ik_constraint_get_target =
      _spine_ik_constraint_get_targetPtr.asFunction<spine_bone Function(spine_ik_constraint)>();

  void spine_ik_constraint_set_target(
    spine_ik_constraint self,
    spine_bone inValue,
  ) {
    return _spine_ik_constraint_set_target(
      self,
      inValue,
    );
  }

  late final _spine_ik_constraint_set_targetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, spine_bone)>>('spine_ik_constraint_set_target');
  late final _spine_ik_constraint_set_target =
      _spine_ik_constraint_set_targetPtr.asFunction<void Function(spine_ik_constraint, spine_bone)>();

  /// Adjusts the bone rotation so the tip is as close to the target position as
  /// possible. The target is specified in the world coordinate system.
  void spine_ik_constraint_apply_1(
    spine_skeleton skeleton,
    spine_bone_pose bone,
    double targetX,
    double targetY,
    bool compress,
    bool stretch,
    bool uniform,
    double mix,
  ) {
    return _spine_ik_constraint_apply_1(
      skeleton,
      bone,
      targetX,
      targetY,
      compress,
      stretch,
      uniform,
      mix,
    );
  }

  late final _spine_ik_constraint_apply_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton, spine_bone_pose, ffi.Float, ffi.Float, ffi.Bool, ffi.Bool, ffi.Bool,
              ffi.Float)>>('spine_ik_constraint_apply_1');
  late final _spine_ik_constraint_apply_1 = _spine_ik_constraint_apply_1Ptr
      .asFunction<void Function(spine_skeleton, spine_bone_pose, double, double, bool, bool, bool, double)>();

  /// Adjusts the parent and child bone rotations so the tip of the child is as
  /// close to the target position as possible. The target is specified in the
  /// world coordinate system.
  ///
  /// @param child A direct descendant of the parent bone.
  void spine_ik_constraint_apply_2(
    spine_skeleton skeleton,
    spine_bone_pose parent,
    spine_bone_pose child,
    double targetX,
    double targetY,
    int bendDirection,
    bool stretch,
    bool uniform,
    double softness,
    double mix,
  ) {
    return _spine_ik_constraint_apply_2(
      skeleton,
      parent,
      child,
      targetX,
      targetY,
      bendDirection,
      stretch,
      uniform,
      softness,
      mix,
    );
  }

  late final _spine_ik_constraint_apply_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton, spine_bone_pose, spine_bone_pose, ffi.Float, ffi.Float, ffi.Int, ffi.Bool,
              ffi.Bool, ffi.Float, ffi.Float)>>('spine_ik_constraint_apply_2');
  late final _spine_ik_constraint_apply_2 = _spine_ik_constraint_apply_2Ptr.asFunction<
      void Function(
          spine_skeleton, spine_bone_pose, spine_bone_pose, double, double, int, bool, bool, double, double)>();

  spine_ik_constraint_data spine_ik_constraint_get_data(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_get_data(
      self,
    );
  }

  late final _spine_ik_constraint_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_data Function(spine_ik_constraint)>>(
          'spine_ik_constraint_get_data');
  late final _spine_ik_constraint_get_data =
      _spine_ik_constraint_get_dataPtr.asFunction<spine_ik_constraint_data Function(spine_ik_constraint)>();

  spine_ik_constraint_pose spine_ik_constraint_get_pose(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_get_pose(
      self,
    );
  }

  late final _spine_ik_constraint_get_posePtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_pose Function(spine_ik_constraint)>>(
          'spine_ik_constraint_get_pose');
  late final _spine_ik_constraint_get_pose =
      _spine_ik_constraint_get_posePtr.asFunction<spine_ik_constraint_pose Function(spine_ik_constraint)>();

  spine_ik_constraint_pose spine_ik_constraint_get_applied_pose(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_get_applied_pose(
      self,
    );
  }

  late final _spine_ik_constraint_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_pose Function(spine_ik_constraint)>>(
          'spine_ik_constraint_get_applied_pose');
  late final _spine_ik_constraint_get_applied_pose =
      _spine_ik_constraint_get_applied_posePtr.asFunction<spine_ik_constraint_pose Function(spine_ik_constraint)>();

  void spine_ik_constraint_reset_constrained(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_reset_constrained(
      self,
    );
  }

  late final _spine_ik_constraint_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint)>>('spine_ik_constraint_reset_constrained');
  late final _spine_ik_constraint_reset_constrained =
      _spine_ik_constraint_reset_constrainedPtr.asFunction<void Function(spine_ik_constraint)>();

  void spine_ik_constraint_constrained(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_constrained(
      self,
    );
  }

  late final _spine_ik_constraint_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint)>>('spine_ik_constraint_constrained');
  late final _spine_ik_constraint_constrained =
      _spine_ik_constraint_constrainedPtr.asFunction<void Function(spine_ik_constraint)>();

  bool spine_ik_constraint_is_pose_equal_to_applied(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_ik_constraint_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint)>>(
          'spine_ik_constraint_is_pose_equal_to_applied');
  late final _spine_ik_constraint_is_pose_equal_to_applied =
      _spine_ik_constraint_is_pose_equal_to_appliedPtr.asFunction<bool Function(spine_ik_constraint)>();

  bool spine_ik_constraint_is_active(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_is_active(
      self,
    );
  }

  late final _spine_ik_constraint_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint)>>('spine_ik_constraint_is_active');
  late final _spine_ik_constraint_is_active =
      _spine_ik_constraint_is_activePtr.asFunction<bool Function(spine_ik_constraint)>();

  void spine_ik_constraint_set_active(
    spine_ik_constraint self,
    bool active,
  ) {
    return _spine_ik_constraint_set_active(
      self,
      active,
    );
  }

  late final _spine_ik_constraint_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, ffi.Bool)>>('spine_ik_constraint_set_active');
  late final _spine_ik_constraint_set_active =
      _spine_ik_constraint_set_activePtr.asFunction<void Function(spine_ik_constraint, bool)>();

  spine_rtti spine_ik_constraint_rtti() {
    return _spine_ik_constraint_rtti();
  }

  late final _spine_ik_constraint_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_ik_constraint_rtti');
  late final _spine_ik_constraint_rtti = _spine_ik_constraint_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_ik_constraint_base_dispose(
    spine_ik_constraint_base self,
  ) {
    return _spine_ik_constraint_base_dispose(
      self,
    );
  }

  late final _spine_ik_constraint_base_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_base)>>('spine_ik_constraint_base_dispose');
  late final _spine_ik_constraint_base_dispose =
      _spine_ik_constraint_base_disposePtr.asFunction<void Function(spine_ik_constraint_base)>();

  spine_ik_constraint_data spine_ik_constraint_base_get_data(
    spine_ik_constraint_base self,
  ) {
    return _spine_ik_constraint_base_get_data(
      self,
    );
  }

  late final _spine_ik_constraint_base_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_data Function(spine_ik_constraint_base)>>(
          'spine_ik_constraint_base_get_data');
  late final _spine_ik_constraint_base_get_data =
      _spine_ik_constraint_base_get_dataPtr.asFunction<spine_ik_constraint_data Function(spine_ik_constraint_base)>();

  spine_ik_constraint_pose spine_ik_constraint_base_get_pose(
    spine_ik_constraint_base self,
  ) {
    return _spine_ik_constraint_base_get_pose(
      self,
    );
  }

  late final _spine_ik_constraint_base_get_posePtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_pose Function(spine_ik_constraint_base)>>(
          'spine_ik_constraint_base_get_pose');
  late final _spine_ik_constraint_base_get_pose =
      _spine_ik_constraint_base_get_posePtr.asFunction<spine_ik_constraint_pose Function(spine_ik_constraint_base)>();

  spine_ik_constraint_pose spine_ik_constraint_base_get_applied_pose(
    spine_ik_constraint_base self,
  ) {
    return _spine_ik_constraint_base_get_applied_pose(
      self,
    );
  }

  late final _spine_ik_constraint_base_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_pose Function(spine_ik_constraint_base)>>(
          'spine_ik_constraint_base_get_applied_pose');
  late final _spine_ik_constraint_base_get_applied_pose = _spine_ik_constraint_base_get_applied_posePtr
      .asFunction<spine_ik_constraint_pose Function(spine_ik_constraint_base)>();

  void spine_ik_constraint_base_reset_constrained(
    spine_ik_constraint_base self,
  ) {
    return _spine_ik_constraint_base_reset_constrained(
      self,
    );
  }

  late final _spine_ik_constraint_base_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_base)>>(
          'spine_ik_constraint_base_reset_constrained');
  late final _spine_ik_constraint_base_reset_constrained =
      _spine_ik_constraint_base_reset_constrainedPtr.asFunction<void Function(spine_ik_constraint_base)>();

  void spine_ik_constraint_base_constrained(
    spine_ik_constraint_base self,
  ) {
    return _spine_ik_constraint_base_constrained(
      self,
    );
  }

  late final _spine_ik_constraint_base_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_base)>>('spine_ik_constraint_base_constrained');
  late final _spine_ik_constraint_base_constrained =
      _spine_ik_constraint_base_constrainedPtr.asFunction<void Function(spine_ik_constraint_base)>();

  bool spine_ik_constraint_base_is_pose_equal_to_applied(
    spine_ik_constraint_base self,
  ) {
    return _spine_ik_constraint_base_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_ik_constraint_base_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint_base)>>(
          'spine_ik_constraint_base_is_pose_equal_to_applied');
  late final _spine_ik_constraint_base_is_pose_equal_to_applied =
      _spine_ik_constraint_base_is_pose_equal_to_appliedPtr.asFunction<bool Function(spine_ik_constraint_base)>();

  bool spine_ik_constraint_base_is_active(
    spine_ik_constraint_base self,
  ) {
    return _spine_ik_constraint_base_is_active(
      self,
    );
  }

  late final _spine_ik_constraint_base_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint_base)>>('spine_ik_constraint_base_is_active');
  late final _spine_ik_constraint_base_is_active =
      _spine_ik_constraint_base_is_activePtr.asFunction<bool Function(spine_ik_constraint_base)>();

  void spine_ik_constraint_base_set_active(
    spine_ik_constraint_base self,
    bool active,
  ) {
    return _spine_ik_constraint_base_set_active(
      self,
      active,
    );
  }

  late final _spine_ik_constraint_base_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_base, ffi.Bool)>>(
          'spine_ik_constraint_base_set_active');
  late final _spine_ik_constraint_base_set_active =
      _spine_ik_constraint_base_set_activePtr.asFunction<void Function(spine_ik_constraint_base, bool)>();

  spine_rtti spine_ik_constraint_base_get_rtti(
    spine_ik_constraint_base self,
  ) {
    return _spine_ik_constraint_base_get_rtti(
      self,
    );
  }

  late final _spine_ik_constraint_base_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_ik_constraint_base)>>('spine_ik_constraint_base_get_rtti');
  late final _spine_ik_constraint_base_get_rtti =
      _spine_ik_constraint_base_get_rttiPtr.asFunction<spine_rtti Function(spine_ik_constraint_base)>();

  void spine_ik_constraint_base_sort(
    spine_ik_constraint_base self,
    spine_skeleton skeleton,
  ) {
    return _spine_ik_constraint_base_sort(
      self,
      skeleton,
    );
  }

  late final _spine_ik_constraint_base_sortPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_base, spine_skeleton)>>(
          'spine_ik_constraint_base_sort');
  late final _spine_ik_constraint_base_sort =
      _spine_ik_constraint_base_sortPtr.asFunction<void Function(spine_ik_constraint_base, spine_skeleton)>();

  bool spine_ik_constraint_base_is_source_active(
    spine_ik_constraint_base self,
  ) {
    return _spine_ik_constraint_base_is_source_active(
      self,
    );
  }

  late final _spine_ik_constraint_base_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint_base)>>(
          'spine_ik_constraint_base_is_source_active');
  late final _spine_ik_constraint_base_is_source_active =
      _spine_ik_constraint_base_is_source_activePtr.asFunction<bool Function(spine_ik_constraint_base)>();

  /// Inherited from Update
  void spine_ik_constraint_base_update(
    spine_ik_constraint_base self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_ik_constraint_base_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_ik_constraint_base_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_base, spine_skeleton, ffi.Int32)>>(
          'spine_ik_constraint_base_update');
  late final _spine_ik_constraint_base_update =
      _spine_ik_constraint_base_updatePtr.asFunction<void Function(spine_ik_constraint_base, spine_skeleton, int)>();

  spine_rtti spine_ik_constraint_base_rtti() {
    return _spine_ik_constraint_base_rtti();
  }

  late final _spine_ik_constraint_base_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_ik_constraint_base_rtti');
  late final _spine_ik_constraint_base_rtti = _spine_ik_constraint_base_rttiPtr.asFunction<spine_rtti Function()>();

  spine_ik_constraint_data spine_ik_constraint_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_ik_constraint_data_create(
      name,
    );
  }

  late final _spine_ik_constraint_data_createPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_data Function(ffi.Pointer<ffi.Char>)>>(
          'spine_ik_constraint_data_create');
  late final _spine_ik_constraint_data_create =
      _spine_ik_constraint_data_createPtr.asFunction<spine_ik_constraint_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_ik_constraint_data_dispose(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_dispose(
      self,
    );
  }

  late final _spine_ik_constraint_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data)>>('spine_ik_constraint_data_dispose');
  late final _spine_ik_constraint_data_dispose =
      _spine_ik_constraint_data_disposePtr.asFunction<void Function(spine_ik_constraint_data)>();

  spine_rtti spine_ik_constraint_data_get_rtti(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_rtti(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_ik_constraint_data)>>('spine_ik_constraint_data_get_rtti');
  late final _spine_ik_constraint_data_get_rtti =
      _spine_ik_constraint_data_get_rttiPtr.asFunction<spine_rtti Function(spine_ik_constraint_data)>();

  spine_constraint spine_ik_constraint_data_create_method(
    spine_ik_constraint_data self,
    spine_skeleton skeleton,
  ) {
    return _spine_ik_constraint_data_create_method(
      self,
      skeleton,
    );
  }

  late final _spine_ik_constraint_data_create_methodPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_ik_constraint_data, spine_skeleton)>>(
          'spine_ik_constraint_data_create_method');
  late final _spine_ik_constraint_data_create_method = _spine_ik_constraint_data_create_methodPtr
      .asFunction<spine_constraint Function(spine_ik_constraint_data, spine_skeleton)>();

  /// The bones that are constrained by this IK Constraint.
  spine_array_bone_data spine_ik_constraint_data_get_bones(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_bones(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_bone_data Function(spine_ik_constraint_data)>>(
          'spine_ik_constraint_data_get_bones');
  late final _spine_ik_constraint_data_get_bones =
      _spine_ik_constraint_data_get_bonesPtr.asFunction<spine_array_bone_data Function(spine_ik_constraint_data)>();

  /// The bone that is the IK target.
  spine_bone_data spine_ik_constraint_data_get_target(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_target(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_targetPtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_ik_constraint_data)>>(
          'spine_ik_constraint_data_get_target');
  late final _spine_ik_constraint_data_get_target =
      _spine_ik_constraint_data_get_targetPtr.asFunction<spine_bone_data Function(spine_ik_constraint_data)>();

  void spine_ik_constraint_data_set_target(
    spine_ik_constraint_data self,
    spine_bone_data inValue,
  ) {
    return _spine_ik_constraint_data_set_target(
      self,
      inValue,
    );
  }

  late final _spine_ik_constraint_data_set_targetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, spine_bone_data)>>(
          'spine_ik_constraint_data_set_target');
  late final _spine_ik_constraint_data_set_target =
      _spine_ik_constraint_data_set_targetPtr.asFunction<void Function(spine_ik_constraint_data, spine_bone_data)>();

  /// When true and IkConstraintPose compress or stretch is used, the bone is
  /// scaled on both the X and Y axes.
  bool spine_ik_constraint_data_get_uniform(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_uniform(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_uniformPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint_data)>>('spine_ik_constraint_data_get_uniform');
  late final _spine_ik_constraint_data_get_uniform =
      _spine_ik_constraint_data_get_uniformPtr.asFunction<bool Function(spine_ik_constraint_data)>();

  void spine_ik_constraint_data_set_uniform(
    spine_ik_constraint_data self,
    bool uniform,
  ) {
    return _spine_ik_constraint_data_set_uniform(
      self,
      uniform,
    );
  }

  late final _spine_ik_constraint_data_set_uniformPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, ffi.Bool)>>(
          'spine_ik_constraint_data_set_uniform');
  late final _spine_ik_constraint_data_set_uniform =
      _spine_ik_constraint_data_set_uniformPtr.asFunction<void Function(spine_ik_constraint_data, bool)>();

  /// Resolve ambiguity by forwarding to PosedData's implementation
  ffi.Pointer<ffi.Char> spine_ik_constraint_data_get_name(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_name(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_ik_constraint_data)>>(
          'spine_ik_constraint_data_get_name');
  late final _spine_ik_constraint_data_get_name =
      _spine_ik_constraint_data_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_ik_constraint_data)>();

  bool spine_ik_constraint_data_get_skin_required(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_skin_required(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint_data)>>(
          'spine_ik_constraint_data_get_skin_required');
  late final _spine_ik_constraint_data_get_skin_required =
      _spine_ik_constraint_data_get_skin_requiredPtr.asFunction<bool Function(spine_ik_constraint_data)>();

  spine_ik_constraint_pose spine_ik_constraint_data_get_setup_pose(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_setup_pose(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_setup_posePtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_pose Function(spine_ik_constraint_data)>>(
          'spine_ik_constraint_data_get_setup_pose');
  late final _spine_ik_constraint_data_get_setup_pose = _spine_ik_constraint_data_get_setup_posePtr
      .asFunction<spine_ik_constraint_pose Function(spine_ik_constraint_data)>();

  void spine_ik_constraint_data_set_skin_required(
    spine_ik_constraint_data self,
    bool skinRequired,
  ) {
    return _spine_ik_constraint_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_ik_constraint_data_set_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, ffi.Bool)>>(
          'spine_ik_constraint_data_set_skin_required');
  late final _spine_ik_constraint_data_set_skin_required =
      _spine_ik_constraint_data_set_skin_requiredPtr.asFunction<void Function(spine_ik_constraint_data, bool)>();

  spine_rtti spine_ik_constraint_data_rtti() {
    return _spine_ik_constraint_data_rtti();
  }

  late final _spine_ik_constraint_data_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_ik_constraint_data_rtti');
  late final _spine_ik_constraint_data_rtti = _spine_ik_constraint_data_rttiPtr.asFunction<spine_rtti Function()>();

  spine_ik_constraint_pose spine_ik_constraint_pose_create() {
    return _spine_ik_constraint_pose_create();
  }

  late final _spine_ik_constraint_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_pose Function()>>('spine_ik_constraint_pose_create');
  late final _spine_ik_constraint_pose_create =
      _spine_ik_constraint_pose_createPtr.asFunction<spine_ik_constraint_pose Function()>();

  void spine_ik_constraint_pose_dispose(
    spine_ik_constraint_pose self,
  ) {
    return _spine_ik_constraint_pose_dispose(
      self,
    );
  }

  late final _spine_ik_constraint_pose_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_pose)>>('spine_ik_constraint_pose_dispose');
  late final _spine_ik_constraint_pose_dispose =
      _spine_ik_constraint_pose_disposePtr.asFunction<void Function(spine_ik_constraint_pose)>();

  void spine_ik_constraint_pose_set(
    spine_ik_constraint_pose self,
    spine_ik_constraint_pose pose,
  ) {
    return _spine_ik_constraint_pose_set(
      self,
      pose,
    );
  }

  late final _spine_ik_constraint_pose_setPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_pose, spine_ik_constraint_pose)>>(
          'spine_ik_constraint_pose_set');
  late final _spine_ik_constraint_pose_set =
      _spine_ik_constraint_pose_setPtr.asFunction<void Function(spine_ik_constraint_pose, spine_ik_constraint_pose)>();

  /// A percentage (0-1) that controls the mix between the constrained and
  /// unconstrained rotation.
  ///
  /// For two bone IK: if the parent bone has local nonuniform scale, the child
  /// bone's local Y translation is set to 0.
  double spine_ik_constraint_pose_get_mix(
    spine_ik_constraint_pose self,
  ) {
    return _spine_ik_constraint_pose_get_mix(
      self,
    );
  }

  late final _spine_ik_constraint_pose_get_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint_pose)>>('spine_ik_constraint_pose_get_mix');
  late final _spine_ik_constraint_pose_get_mix =
      _spine_ik_constraint_pose_get_mixPtr.asFunction<double Function(spine_ik_constraint_pose)>();

  void spine_ik_constraint_pose_set_mix(
    spine_ik_constraint_pose self,
    double mix,
  ) {
    return _spine_ik_constraint_pose_set_mix(
      self,
      mix,
    );
  }

  late final _spine_ik_constraint_pose_set_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_pose, ffi.Float)>>(
          'spine_ik_constraint_pose_set_mix');
  late final _spine_ik_constraint_pose_set_mix =
      _spine_ik_constraint_pose_set_mixPtr.asFunction<void Function(spine_ik_constraint_pose, double)>();

  /// For two bone IK, the target bone's distance from the maximum reach of the
  /// bones where rotation begins to slow. The bones will not straighten completely
  /// until the target is this far out of range.
  double spine_ik_constraint_pose_get_softness(
    spine_ik_constraint_pose self,
  ) {
    return _spine_ik_constraint_pose_get_softness(
      self,
    );
  }

  late final _spine_ik_constraint_pose_get_softnessPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint_pose)>>(
          'spine_ik_constraint_pose_get_softness');
  late final _spine_ik_constraint_pose_get_softness =
      _spine_ik_constraint_pose_get_softnessPtr.asFunction<double Function(spine_ik_constraint_pose)>();

  void spine_ik_constraint_pose_set_softness(
    spine_ik_constraint_pose self,
    double softness,
  ) {
    return _spine_ik_constraint_pose_set_softness(
      self,
      softness,
    );
  }

  late final _spine_ik_constraint_pose_set_softnessPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_pose, ffi.Float)>>(
          'spine_ik_constraint_pose_set_softness');
  late final _spine_ik_constraint_pose_set_softness =
      _spine_ik_constraint_pose_set_softnessPtr.asFunction<void Function(spine_ik_constraint_pose, double)>();

  /// For two bone IK, controls the bend direction of the IK bones, either 1 or -1.
  int spine_ik_constraint_pose_get_bend_direction(
    spine_ik_constraint_pose self,
  ) {
    return _spine_ik_constraint_pose_get_bend_direction(
      self,
    );
  }

  late final _spine_ik_constraint_pose_get_bend_directionPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_ik_constraint_pose)>>(
          'spine_ik_constraint_pose_get_bend_direction');
  late final _spine_ik_constraint_pose_get_bend_direction =
      _spine_ik_constraint_pose_get_bend_directionPtr.asFunction<int Function(spine_ik_constraint_pose)>();

  void spine_ik_constraint_pose_set_bend_direction(
    spine_ik_constraint_pose self,
    int bendDirection,
  ) {
    return _spine_ik_constraint_pose_set_bend_direction(
      self,
      bendDirection,
    );
  }

  late final _spine_ik_constraint_pose_set_bend_directionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_pose, ffi.Int)>>(
          'spine_ik_constraint_pose_set_bend_direction');
  late final _spine_ik_constraint_pose_set_bend_direction =
      _spine_ik_constraint_pose_set_bend_directionPtr.asFunction<void Function(spine_ik_constraint_pose, int)>();

  /// For one bone IK, when true and the target is too close, the bone is scaled to
  /// reach it.
  bool spine_ik_constraint_pose_get_compress(
    spine_ik_constraint_pose self,
  ) {
    return _spine_ik_constraint_pose_get_compress(
      self,
    );
  }

  late final _spine_ik_constraint_pose_get_compressPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint_pose)>>('spine_ik_constraint_pose_get_compress');
  late final _spine_ik_constraint_pose_get_compress =
      _spine_ik_constraint_pose_get_compressPtr.asFunction<bool Function(spine_ik_constraint_pose)>();

  void spine_ik_constraint_pose_set_compress(
    spine_ik_constraint_pose self,
    bool compress,
  ) {
    return _spine_ik_constraint_pose_set_compress(
      self,
      compress,
    );
  }

  late final _spine_ik_constraint_pose_set_compressPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_pose, ffi.Bool)>>(
          'spine_ik_constraint_pose_set_compress');
  late final _spine_ik_constraint_pose_set_compress =
      _spine_ik_constraint_pose_set_compressPtr.asFunction<void Function(spine_ik_constraint_pose, bool)>();

  /// When true and the target is out of range, the parent bone is scaled to reach
  /// it.
  ///
  /// For two bone IK: 1) the child bone's local Y translation is set to 0, 2)
  /// stretch is not applied if getSoftness() is > 0, and 3) if the parent bone has
  /// local nonuniform scale, stretch is not applied.
  bool spine_ik_constraint_pose_get_stretch(
    spine_ik_constraint_pose self,
  ) {
    return _spine_ik_constraint_pose_get_stretch(
      self,
    );
  }

  late final _spine_ik_constraint_pose_get_stretchPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint_pose)>>('spine_ik_constraint_pose_get_stretch');
  late final _spine_ik_constraint_pose_get_stretch =
      _spine_ik_constraint_pose_get_stretchPtr.asFunction<bool Function(spine_ik_constraint_pose)>();

  void spine_ik_constraint_pose_set_stretch(
    spine_ik_constraint_pose self,
    bool stretch,
  ) {
    return _spine_ik_constraint_pose_set_stretch(
      self,
      stretch,
    );
  }

  late final _spine_ik_constraint_pose_set_stretchPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_pose, ffi.Bool)>>(
          'spine_ik_constraint_pose_set_stretch');
  late final _spine_ik_constraint_pose_set_stretch =
      _spine_ik_constraint_pose_set_stretchPtr.asFunction<void Function(spine_ik_constraint_pose, bool)>();

  spine_ik_constraint_timeline spine_ik_constraint_timeline_create(
    int frameCount,
    int bezierCount,
    int constraintIndex,
  ) {
    return _spine_ik_constraint_timeline_create(
      frameCount,
      bezierCount,
      constraintIndex,
    );
  }

  late final _spine_ik_constraint_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_ik_constraint_timeline_create');
  late final _spine_ik_constraint_timeline_create =
      _spine_ik_constraint_timeline_createPtr.asFunction<spine_ik_constraint_timeline Function(int, int, int)>();

  void spine_ik_constraint_timeline_dispose(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_dispose(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_timeline)>>(
          'spine_ik_constraint_timeline_dispose');
  late final _spine_ik_constraint_timeline_dispose =
      _spine_ik_constraint_timeline_disposePtr.asFunction<void Function(spine_ik_constraint_timeline)>();

  spine_rtti spine_ik_constraint_timeline_get_rtti(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_rtti(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_ik_constraint_timeline)>>(
          'spine_ik_constraint_timeline_get_rtti');
  late final _spine_ik_constraint_timeline_get_rtti =
      _spine_ik_constraint_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_ik_constraint_timeline)>();

  void spine_ik_constraint_timeline_apply(
    spine_ik_constraint_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_ik_constraint_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_ik_constraint_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event,
              ffi.Float, ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_ik_constraint_timeline_apply');
  late final _spine_ik_constraint_timeline_apply = _spine_ik_constraint_timeline_applyPtr.asFunction<
      void Function(
          spine_ik_constraint_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  /// Sets the time, mix, softness, bend direction, compress, and stretch for the
  /// specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  /// @param bendDirection 1 or -1.
  void spine_ik_constraint_timeline_set_frame(
    spine_ik_constraint_timeline self,
    int frame,
    double time,
    double mix,
    double softness,
    int bendDirection,
    bool compress,
    bool stretch,
  ) {
    return _spine_ik_constraint_timeline_set_frame(
      self,
      frame,
      time,
      mix,
      softness,
      bendDirection,
      compress,
      stretch,
    );
  }

  late final _spine_ik_constraint_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_timeline, ffi.Int, ffi.Float, ffi.Float, ffi.Float, ffi.Int, ffi.Bool,
              ffi.Bool)>>('spine_ik_constraint_timeline_set_frame');
  late final _spine_ik_constraint_timeline_set_frame = _spine_ik_constraint_timeline_set_framePtr
      .asFunction<void Function(spine_ik_constraint_timeline, int, double, double, double, int, bool, bool)>();

  int spine_ik_constraint_timeline_get_constraint_index(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_ik_constraint_timeline)>>(
          'spine_ik_constraint_timeline_get_constraint_index');
  late final _spine_ik_constraint_timeline_get_constraint_index =
      _spine_ik_constraint_timeline_get_constraint_indexPtr.asFunction<int Function(spine_ik_constraint_timeline)>();

  void spine_ik_constraint_timeline_set_constraint_index(
    spine_ik_constraint_timeline self,
    int inValue,
  ) {
    return _spine_ik_constraint_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_ik_constraint_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_timeline, ffi.Int)>>(
          'spine_ik_constraint_timeline_set_constraint_index');
  late final _spine_ik_constraint_timeline_set_constraint_index = _spine_ik_constraint_timeline_set_constraint_indexPtr
      .asFunction<void Function(spine_ik_constraint_timeline, int)>();

  void spine_ik_constraint_timeline_set_linear(
    spine_ik_constraint_timeline self,
    int frame,
  ) {
    return _spine_ik_constraint_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_ik_constraint_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_timeline, ffi.Size)>>(
          'spine_ik_constraint_timeline_set_linear');
  late final _spine_ik_constraint_timeline_set_linear =
      _spine_ik_constraint_timeline_set_linearPtr.asFunction<void Function(spine_ik_constraint_timeline, int)>();

  void spine_ik_constraint_timeline_set_stepped(
    spine_ik_constraint_timeline self,
    int frame,
  ) {
    return _spine_ik_constraint_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_ik_constraint_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_timeline, ffi.Size)>>(
          'spine_ik_constraint_timeline_set_stepped');
  late final _spine_ik_constraint_timeline_set_stepped =
      _spine_ik_constraint_timeline_set_steppedPtr.asFunction<void Function(spine_ik_constraint_timeline, int)>();

  void spine_ik_constraint_timeline_set_bezier(
    spine_ik_constraint_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_ik_constraint_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_ik_constraint_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_ik_constraint_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_ik_constraint_timeline_set_bezier');
  late final _spine_ik_constraint_timeline_set_bezier = _spine_ik_constraint_timeline_set_bezierPtr.asFunction<
      void Function(spine_ik_constraint_timeline, int, int, double, double, double, double, double, double, double,
          double, double)>();

  double spine_ik_constraint_timeline_get_bezier_value(
    spine_ik_constraint_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_ik_constraint_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_ik_constraint_timeline_get_bezier_valuePtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_ik_constraint_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
      'spine_ik_constraint_timeline_get_bezier_value');
  late final _spine_ik_constraint_timeline_get_bezier_value = _spine_ik_constraint_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_ik_constraint_timeline, double, int, int, int)>();

  spine_array_float spine_ik_constraint_timeline_get_curves(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_curves(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_ik_constraint_timeline)>>(
          'spine_ik_constraint_timeline_get_curves');
  late final _spine_ik_constraint_timeline_get_curves = _spine_ik_constraint_timeline_get_curvesPtr
      .asFunction<spine_array_float Function(spine_ik_constraint_timeline)>();

  int spine_ik_constraint_timeline_get_frame_entries(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_ik_constraint_timeline)>>(
          'spine_ik_constraint_timeline_get_frame_entries');
  late final _spine_ik_constraint_timeline_get_frame_entries =
      _spine_ik_constraint_timeline_get_frame_entriesPtr.asFunction<int Function(spine_ik_constraint_timeline)>();

  int spine_ik_constraint_timeline_get_frame_count(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_ik_constraint_timeline)>>(
          'spine_ik_constraint_timeline_get_frame_count');
  late final _spine_ik_constraint_timeline_get_frame_count =
      _spine_ik_constraint_timeline_get_frame_countPtr.asFunction<int Function(spine_ik_constraint_timeline)>();

  spine_array_float spine_ik_constraint_timeline_get_frames(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_frames(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_ik_constraint_timeline)>>(
          'spine_ik_constraint_timeline_get_frames');
  late final _spine_ik_constraint_timeline_get_frames = _spine_ik_constraint_timeline_get_framesPtr
      .asFunction<spine_array_float Function(spine_ik_constraint_timeline)>();

  double spine_ik_constraint_timeline_get_duration(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_duration(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint_timeline)>>(
          'spine_ik_constraint_timeline_get_duration');
  late final _spine_ik_constraint_timeline_get_duration =
      _spine_ik_constraint_timeline_get_durationPtr.asFunction<double Function(spine_ik_constraint_timeline)>();

  spine_array_property_id spine_ik_constraint_timeline_get_property_ids(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_ik_constraint_timeline)>>(
          'spine_ik_constraint_timeline_get_property_ids');
  late final _spine_ik_constraint_timeline_get_property_ids = _spine_ik_constraint_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_ik_constraint_timeline)>();

  spine_rtti spine_ik_constraint_timeline_rtti() {
    return _spine_ik_constraint_timeline_rtti();
  }

  late final _spine_ik_constraint_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_ik_constraint_timeline_rtti');
  late final _spine_ik_constraint_timeline_rtti =
      _spine_ik_constraint_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_inherit_timeline spine_inherit_timeline_create(
    int frameCount,
    int boneIndex,
  ) {
    return _spine_inherit_timeline_create(
      frameCount,
      boneIndex,
    );
  }

  late final _spine_inherit_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_inherit_timeline Function(ffi.Size, ffi.Int)>>('spine_inherit_timeline_create');
  late final _spine_inherit_timeline_create =
      _spine_inherit_timeline_createPtr.asFunction<spine_inherit_timeline Function(int, int)>();

  void spine_inherit_timeline_dispose(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_dispose(
      self,
    );
  }

  late final _spine_inherit_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_inherit_timeline)>>('spine_inherit_timeline_dispose');
  late final _spine_inherit_timeline_dispose =
      _spine_inherit_timeline_disposePtr.asFunction<void Function(spine_inherit_timeline)>();

  spine_rtti spine_inherit_timeline_get_rtti(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_rtti(
      self,
    );
  }

  late final _spine_inherit_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_inherit_timeline)>>('spine_inherit_timeline_get_rtti');
  late final _spine_inherit_timeline_get_rtti =
      _spine_inherit_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_inherit_timeline)>();

  /// Sets the inherit transform mode for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_inherit_timeline_set_frame(
    spine_inherit_timeline self,
    int frame,
    double time,
    int inherit,
  ) {
    return _spine_inherit_timeline_set_frame(
      self,
      frame,
      time,
      inherit,
    );
  }

  late final _spine_inherit_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_inherit_timeline, ffi.Int, ffi.Float, ffi.Int32)>>(
          'spine_inherit_timeline_set_frame');
  late final _spine_inherit_timeline_set_frame =
      _spine_inherit_timeline_set_framePtr.asFunction<void Function(spine_inherit_timeline, int, double, int)>();

  void spine_inherit_timeline_apply(
    spine_inherit_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_inherit_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_inherit_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_inherit_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_inherit_timeline_apply');
  late final _spine_inherit_timeline_apply = _spine_inherit_timeline_applyPtr.asFunction<
      void Function(
          spine_inherit_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_inherit_timeline_get_bone_index(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_inherit_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_inherit_timeline)>>('spine_inherit_timeline_get_bone_index');
  late final _spine_inherit_timeline_get_bone_index =
      _spine_inherit_timeline_get_bone_indexPtr.asFunction<int Function(spine_inherit_timeline)>();

  void spine_inherit_timeline_set_bone_index(
    spine_inherit_timeline self,
    int inValue,
  ) {
    return _spine_inherit_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_inherit_timeline_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_inherit_timeline, ffi.Int)>>(
          'spine_inherit_timeline_set_bone_index');
  late final _spine_inherit_timeline_set_bone_index =
      _spine_inherit_timeline_set_bone_indexPtr.asFunction<void Function(spine_inherit_timeline, int)>();

  int spine_inherit_timeline_get_frame_entries(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_inherit_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_inherit_timeline)>>(
          'spine_inherit_timeline_get_frame_entries');
  late final _spine_inherit_timeline_get_frame_entries =
      _spine_inherit_timeline_get_frame_entriesPtr.asFunction<int Function(spine_inherit_timeline)>();

  int spine_inherit_timeline_get_frame_count(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_inherit_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_inherit_timeline)>>('spine_inherit_timeline_get_frame_count');
  late final _spine_inherit_timeline_get_frame_count =
      _spine_inherit_timeline_get_frame_countPtr.asFunction<int Function(spine_inherit_timeline)>();

  spine_array_float spine_inherit_timeline_get_frames(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_frames(
      self,
    );
  }

  late final _spine_inherit_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_inherit_timeline)>>(
          'spine_inherit_timeline_get_frames');
  late final _spine_inherit_timeline_get_frames =
      _spine_inherit_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_inherit_timeline)>();

  double spine_inherit_timeline_get_duration(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_duration(
      self,
    );
  }

  late final _spine_inherit_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_inherit_timeline)>>('spine_inherit_timeline_get_duration');
  late final _spine_inherit_timeline_get_duration =
      _spine_inherit_timeline_get_durationPtr.asFunction<double Function(spine_inherit_timeline)>();

  spine_array_property_id spine_inherit_timeline_get_property_ids(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_inherit_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_inherit_timeline)>>(
          'spine_inherit_timeline_get_property_ids');
  late final _spine_inherit_timeline_get_property_ids = _spine_inherit_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_inherit_timeline)>();

  spine_rtti spine_inherit_timeline_rtti() {
    return _spine_inherit_timeline_rtti();
  }

  late final _spine_inherit_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_inherit_timeline_rtti');
  late final _spine_inherit_timeline_rtti = _spine_inherit_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_linked_mesh spine_linked_mesh_create(
    spine_mesh_attachment mesh,
    int skinIndex,
    int slotIndex,
    ffi.Pointer<ffi.Char> parent,
    bool inheritTimelines,
  ) {
    return _spine_linked_mesh_create(
      mesh,
      skinIndex,
      slotIndex,
      parent,
      inheritTimelines,
    );
  }

  late final _spine_linked_mesh_createPtr = _lookup<
      ffi.NativeFunction<
          spine_linked_mesh Function(
              spine_mesh_attachment, ffi.Int, ffi.Size, ffi.Pointer<ffi.Char>, ffi.Bool)>>('spine_linked_mesh_create');
  late final _spine_linked_mesh_create = _spine_linked_mesh_createPtr
      .asFunction<spine_linked_mesh Function(spine_mesh_attachment, int, int, ffi.Pointer<ffi.Char>, bool)>();

  spine_linked_mesh spine_linked_mesh_create2(
    spine_mesh_attachment mesh,
    ffi.Pointer<ffi.Char> skin,
    int slotIndex,
    ffi.Pointer<ffi.Char> parent,
    bool inheritTimelines,
  ) {
    return _spine_linked_mesh_create2(
      mesh,
      skin,
      slotIndex,
      parent,
      inheritTimelines,
    );
  }

  late final _spine_linked_mesh_create2Ptr = _lookup<
      ffi.NativeFunction<
          spine_linked_mesh Function(spine_mesh_attachment, ffi.Pointer<ffi.Char>, ffi.Size, ffi.Pointer<ffi.Char>,
              ffi.Bool)>>('spine_linked_mesh_create2');
  late final _spine_linked_mesh_create2 = _spine_linked_mesh_create2Ptr.asFunction<
      spine_linked_mesh Function(spine_mesh_attachment, ffi.Pointer<ffi.Char>, int, ffi.Pointer<ffi.Char>, bool)>();

  void spine_linked_mesh_dispose(
    spine_linked_mesh self,
  ) {
    return _spine_linked_mesh_dispose(
      self,
    );
  }

  late final _spine_linked_mesh_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_linked_mesh)>>('spine_linked_mesh_dispose');
  late final _spine_linked_mesh_dispose = _spine_linked_mesh_disposePtr.asFunction<void Function(spine_linked_mesh)>();

  spine_mesh_attachment spine_mesh_attachment_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_mesh_attachment_create(
      name,
    );
  }

  late final _spine_mesh_attachment_createPtr =
      _lookup<ffi.NativeFunction<spine_mesh_attachment Function(ffi.Pointer<ffi.Char>)>>(
          'spine_mesh_attachment_create');
  late final _spine_mesh_attachment_create =
      _spine_mesh_attachment_createPtr.asFunction<spine_mesh_attachment Function(ffi.Pointer<ffi.Char>)>();

  void spine_mesh_attachment_dispose(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_dispose(
      self,
    );
  }

  late final _spine_mesh_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment)>>('spine_mesh_attachment_dispose');
  late final _spine_mesh_attachment_dispose =
      _spine_mesh_attachment_disposePtr.asFunction<void Function(spine_mesh_attachment)>();

  spine_rtti spine_mesh_attachment_get_rtti(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_rtti(
      self,
    );
  }

  late final _spine_mesh_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_rtti');
  late final _spine_mesh_attachment_get_rtti =
      _spine_mesh_attachment_get_rttiPtr.asFunction<spine_rtti Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_compute_world_vertices_1(
    spine_mesh_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    ffi.Pointer<ffi.Float> worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_mesh_attachment_compute_world_vertices_1(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_mesh_attachment_compute_world_vertices_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_mesh_attachment, spine_skeleton, spine_slot, ffi.Size, ffi.Size,
              ffi.Pointer<ffi.Float>, ffi.Size, ffi.Size)>>('spine_mesh_attachment_compute_world_vertices_1');
  late final _spine_mesh_attachment_compute_world_vertices_1 =
      _spine_mesh_attachment_compute_world_vertices_1Ptr.asFunction<
          void Function(
              spine_mesh_attachment, spine_skeleton, spine_slot, int, int, ffi.Pointer<ffi.Float>, int, int)>();

  void spine_mesh_attachment_compute_world_vertices_2(
    spine_mesh_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    spine_array_float worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_mesh_attachment_compute_world_vertices_2(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_mesh_attachment_compute_world_vertices_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_mesh_attachment, spine_skeleton, spine_slot, ffi.Size, ffi.Size, spine_array_float,
              ffi.Size, ffi.Size)>>('spine_mesh_attachment_compute_world_vertices_2');
  late final _spine_mesh_attachment_compute_world_vertices_2 =
      _spine_mesh_attachment_compute_world_vertices_2Ptr.asFunction<
          void Function(spine_mesh_attachment, spine_skeleton, spine_slot, int, int, spine_array_float, int, int)>();

  void spine_mesh_attachment_update_region(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_update_region(
      self,
    );
  }

  late final _spine_mesh_attachment_update_regionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment)>>('spine_mesh_attachment_update_region');
  late final _spine_mesh_attachment_update_region =
      _spine_mesh_attachment_update_regionPtr.asFunction<void Function(spine_mesh_attachment)>();

  int spine_mesh_attachment_get_hull_length(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_hull_length(
      self,
    );
  }

  late final _spine_mesh_attachment_get_hull_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_hull_length');
  late final _spine_mesh_attachment_get_hull_length =
      _spine_mesh_attachment_get_hull_lengthPtr.asFunction<int Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_hull_length(
    spine_mesh_attachment self,
    int inValue,
  ) {
    return _spine_mesh_attachment_set_hull_length(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_hull_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Int)>>(
          'spine_mesh_attachment_set_hull_length');
  late final _spine_mesh_attachment_set_hull_length =
      _spine_mesh_attachment_set_hull_lengthPtr.asFunction<void Function(spine_mesh_attachment, int)>();

  spine_array_float spine_mesh_attachment_get_region_u_vs(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_region_u_vs(
      self,
    );
  }

  late final _spine_mesh_attachment_get_region_u_vsPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_region_u_vs');
  late final _spine_mesh_attachment_get_region_u_vs =
      _spine_mesh_attachment_get_region_u_vsPtr.asFunction<spine_array_float Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_region_u_vs(
    spine_mesh_attachment self,
    spine_array_float inValue,
  ) {
    return _spine_mesh_attachment_set_region_u_vs(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_region_u_vsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, spine_array_float)>>(
          'spine_mesh_attachment_set_region_u_vs');
  late final _spine_mesh_attachment_set_region_u_vs =
      _spine_mesh_attachment_set_region_u_vsPtr.asFunction<void Function(spine_mesh_attachment, spine_array_float)>();

  /// The UV pair for each vertex, normalized within the entire texture. See also
  /// MeshAttachment::updateRegion
  spine_array_float spine_mesh_attachment_get_u_vs(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_u_vs(
      self,
    );
  }

  late final _spine_mesh_attachment_get_u_vsPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_u_vs');
  late final _spine_mesh_attachment_get_u_vs =
      _spine_mesh_attachment_get_u_vsPtr.asFunction<spine_array_float Function(spine_mesh_attachment)>();

  spine_array_unsigned_short spine_mesh_attachment_get_triangles(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_triangles(
      self,
    );
  }

  late final _spine_mesh_attachment_get_trianglesPtr =
      _lookup<ffi.NativeFunction<spine_array_unsigned_short Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_triangles');
  late final _spine_mesh_attachment_get_triangles =
      _spine_mesh_attachment_get_trianglesPtr.asFunction<spine_array_unsigned_short Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_triangles(
    spine_mesh_attachment self,
    spine_array_unsigned_short inValue,
  ) {
    return _spine_mesh_attachment_set_triangles(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_trianglesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, spine_array_unsigned_short)>>(
          'spine_mesh_attachment_set_triangles');
  late final _spine_mesh_attachment_set_triangles = _spine_mesh_attachment_set_trianglesPtr
      .asFunction<void Function(spine_mesh_attachment, spine_array_unsigned_short)>();

  spine_color spine_mesh_attachment_get_color(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_color(
      self,
    );
  }

  late final _spine_mesh_attachment_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_color');
  late final _spine_mesh_attachment_get_color =
      _spine_mesh_attachment_get_colorPtr.asFunction<spine_color Function(spine_mesh_attachment)>();

  ffi.Pointer<ffi.Char> spine_mesh_attachment_get_path(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_path(
      self,
    );
  }

  late final _spine_mesh_attachment_get_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_path');
  late final _spine_mesh_attachment_get_path =
      _spine_mesh_attachment_get_pathPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_path(
    spine_mesh_attachment self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_mesh_attachment_set_path(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Pointer<ffi.Char>)>>(
          'spine_mesh_attachment_set_path');
  late final _spine_mesh_attachment_set_path =
      _spine_mesh_attachment_set_pathPtr.asFunction<void Function(spine_mesh_attachment, ffi.Pointer<ffi.Char>)>();

  spine_texture_region spine_mesh_attachment_get_region(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_region(
      self,
    );
  }

  late final _spine_mesh_attachment_get_regionPtr =
      _lookup<ffi.NativeFunction<spine_texture_region Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_region');
  late final _spine_mesh_attachment_get_region =
      _spine_mesh_attachment_get_regionPtr.asFunction<spine_texture_region Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_region(
    spine_mesh_attachment self,
    spine_texture_region region,
  ) {
    return _spine_mesh_attachment_set_region(
      self,
      region,
    );
  }

  late final _spine_mesh_attachment_set_regionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, spine_texture_region)>>(
          'spine_mesh_attachment_set_region');
  late final _spine_mesh_attachment_set_region =
      _spine_mesh_attachment_set_regionPtr.asFunction<void Function(spine_mesh_attachment, spine_texture_region)>();

  spine_sequence spine_mesh_attachment_get_sequence(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_sequence(
      self,
    );
  }

  late final _spine_mesh_attachment_get_sequencePtr =
      _lookup<ffi.NativeFunction<spine_sequence Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_sequence');
  late final _spine_mesh_attachment_get_sequence =
      _spine_mesh_attachment_get_sequencePtr.asFunction<spine_sequence Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_sequence(
    spine_mesh_attachment self,
    spine_sequence sequence,
  ) {
    return _spine_mesh_attachment_set_sequence(
      self,
      sequence,
    );
  }

  late final _spine_mesh_attachment_set_sequencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, spine_sequence)>>(
          'spine_mesh_attachment_set_sequence');
  late final _spine_mesh_attachment_set_sequence =
      _spine_mesh_attachment_set_sequencePtr.asFunction<void Function(spine_mesh_attachment, spine_sequence)>();

  spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_parent_mesh(
      self,
    );
  }

  late final _spine_mesh_attachment_get_parent_meshPtr =
      _lookup<ffi.NativeFunction<spine_mesh_attachment Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_parent_mesh');
  late final _spine_mesh_attachment_get_parent_mesh =
      _spine_mesh_attachment_get_parent_meshPtr.asFunction<spine_mesh_attachment Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_parent_mesh(
    spine_mesh_attachment self,
    spine_mesh_attachment inValue,
  ) {
    return _spine_mesh_attachment_set_parent_mesh(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_parent_meshPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, spine_mesh_attachment)>>(
          'spine_mesh_attachment_set_parent_mesh');
  late final _spine_mesh_attachment_set_parent_mesh = _spine_mesh_attachment_set_parent_meshPtr
      .asFunction<void Function(spine_mesh_attachment, spine_mesh_attachment)>();

  /// Nonessential.
  spine_array_unsigned_short spine_mesh_attachment_get_edges(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_edges(
      self,
    );
  }

  late final _spine_mesh_attachment_get_edgesPtr =
      _lookup<ffi.NativeFunction<spine_array_unsigned_short Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_edges');
  late final _spine_mesh_attachment_get_edges =
      _spine_mesh_attachment_get_edgesPtr.asFunction<spine_array_unsigned_short Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_edges(
    spine_mesh_attachment self,
    spine_array_unsigned_short inValue,
  ) {
    return _spine_mesh_attachment_set_edges(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_edgesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, spine_array_unsigned_short)>>(
          'spine_mesh_attachment_set_edges');
  late final _spine_mesh_attachment_set_edges = _spine_mesh_attachment_set_edgesPtr
      .asFunction<void Function(spine_mesh_attachment, spine_array_unsigned_short)>();

  double spine_mesh_attachment_get_width(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_width(
      self,
    );
  }

  late final _spine_mesh_attachment_get_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_width');
  late final _spine_mesh_attachment_get_width =
      _spine_mesh_attachment_get_widthPtr.asFunction<double Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_width(
    spine_mesh_attachment self,
    double inValue,
  ) {
    return _spine_mesh_attachment_set_width(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Float)>>(
          'spine_mesh_attachment_set_width');
  late final _spine_mesh_attachment_set_width =
      _spine_mesh_attachment_set_widthPtr.asFunction<void Function(spine_mesh_attachment, double)>();

  double spine_mesh_attachment_get_height(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_height(
      self,
    );
  }

  late final _spine_mesh_attachment_get_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_height');
  late final _spine_mesh_attachment_get_height =
      _spine_mesh_attachment_get_heightPtr.asFunction<double Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_height(
    spine_mesh_attachment self,
    double inValue,
  ) {
    return _spine_mesh_attachment_set_height(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Float)>>(
          'spine_mesh_attachment_set_height');
  late final _spine_mesh_attachment_set_height =
      _spine_mesh_attachment_set_heightPtr.asFunction<void Function(spine_mesh_attachment, double)>();

  spine_attachment spine_mesh_attachment_copy(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_copy(
      self,
    );
  }

  late final _spine_mesh_attachment_copyPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_mesh_attachment)>>('spine_mesh_attachment_copy');
  late final _spine_mesh_attachment_copy =
      _spine_mesh_attachment_copyPtr.asFunction<spine_attachment Function(spine_mesh_attachment)>();

  spine_mesh_attachment spine_mesh_attachment_new_linked_mesh(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_new_linked_mesh(
      self,
    );
  }

  late final _spine_mesh_attachment_new_linked_meshPtr =
      _lookup<ffi.NativeFunction<spine_mesh_attachment Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_new_linked_mesh');
  late final _spine_mesh_attachment_new_linked_mesh =
      _spine_mesh_attachment_new_linked_meshPtr.asFunction<spine_mesh_attachment Function(spine_mesh_attachment)>();

  /// Gets a unique ID for this attachment.
  int spine_mesh_attachment_get_id(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_id(
      self,
    );
  }

  late final _spine_mesh_attachment_get_idPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_id');
  late final _spine_mesh_attachment_get_id =
      _spine_mesh_attachment_get_idPtr.asFunction<int Function(spine_mesh_attachment)>();

  spine_array_int spine_mesh_attachment_get_bones(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_bones(
      self,
    );
  }

  late final _spine_mesh_attachment_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_int Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_bones');
  late final _spine_mesh_attachment_get_bones =
      _spine_mesh_attachment_get_bonesPtr.asFunction<spine_array_int Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_bones(
    spine_mesh_attachment self,
    spine_array_int bones,
  ) {
    return _spine_mesh_attachment_set_bones(
      self,
      bones,
    );
  }

  late final _spine_mesh_attachment_set_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, spine_array_int)>>(
          'spine_mesh_attachment_set_bones');
  late final _spine_mesh_attachment_set_bones =
      _spine_mesh_attachment_set_bonesPtr.asFunction<void Function(spine_mesh_attachment, spine_array_int)>();

  spine_array_float spine_mesh_attachment_get_vertices(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_vertices(
      self,
    );
  }

  late final _spine_mesh_attachment_get_verticesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_vertices');
  late final _spine_mesh_attachment_get_vertices =
      _spine_mesh_attachment_get_verticesPtr.asFunction<spine_array_float Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_vertices(
    spine_mesh_attachment self,
    spine_array_float vertices,
  ) {
    return _spine_mesh_attachment_set_vertices(
      self,
      vertices,
    );
  }

  late final _spine_mesh_attachment_set_verticesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, spine_array_float)>>(
          'spine_mesh_attachment_set_vertices');
  late final _spine_mesh_attachment_set_vertices =
      _spine_mesh_attachment_set_verticesPtr.asFunction<void Function(spine_mesh_attachment, spine_array_float)>();

  int spine_mesh_attachment_get_world_vertices_length(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_world_vertices_length(
      self,
    );
  }

  late final _spine_mesh_attachment_get_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_world_vertices_length');
  late final _spine_mesh_attachment_get_world_vertices_length =
      _spine_mesh_attachment_get_world_vertices_lengthPtr.asFunction<int Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_world_vertices_length(
    spine_mesh_attachment self,
    int inValue,
  ) {
    return _spine_mesh_attachment_set_world_vertices_length(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Size)>>(
          'spine_mesh_attachment_set_world_vertices_length');
  late final _spine_mesh_attachment_set_world_vertices_length =
      _spine_mesh_attachment_set_world_vertices_lengthPtr.asFunction<void Function(spine_mesh_attachment, int)>();

  spine_attachment spine_mesh_attachment_get_timeline_attachment(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_timeline_attachment(
      self,
    );
  }

  late final _spine_mesh_attachment_get_timeline_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_timeline_attachment');
  late final _spine_mesh_attachment_get_timeline_attachment =
      _spine_mesh_attachment_get_timeline_attachmentPtr.asFunction<spine_attachment Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_timeline_attachment(
    spine_mesh_attachment self,
    spine_attachment attachment,
  ) {
    return _spine_mesh_attachment_set_timeline_attachment(
      self,
      attachment,
    );
  }

  late final _spine_mesh_attachment_set_timeline_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, spine_attachment)>>(
          'spine_mesh_attachment_set_timeline_attachment');
  late final _spine_mesh_attachment_set_timeline_attachment = _spine_mesh_attachment_set_timeline_attachmentPtr
      .asFunction<void Function(spine_mesh_attachment, spine_attachment)>();

  void spine_mesh_attachment_copy_to(
    spine_mesh_attachment self,
    spine_vertex_attachment other,
  ) {
    return _spine_mesh_attachment_copy_to(
      self,
      other,
    );
  }

  late final _spine_mesh_attachment_copy_toPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, spine_vertex_attachment)>>(
          'spine_mesh_attachment_copy_to');
  late final _spine_mesh_attachment_copy_to =
      _spine_mesh_attachment_copy_toPtr.asFunction<void Function(spine_mesh_attachment, spine_vertex_attachment)>();

  ffi.Pointer<ffi.Char> spine_mesh_attachment_get_name(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_name(
      self,
    );
  }

  late final _spine_mesh_attachment_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_name');
  late final _spine_mesh_attachment_get_name =
      _spine_mesh_attachment_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_mesh_attachment)>();

  int spine_mesh_attachment_get_ref_count(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_mesh_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_ref_count');
  late final _spine_mesh_attachment_get_ref_count =
      _spine_mesh_attachment_get_ref_countPtr.asFunction<int Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_reference(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_reference(
      self,
    );
  }

  late final _spine_mesh_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment)>>('spine_mesh_attachment_reference');
  late final _spine_mesh_attachment_reference =
      _spine_mesh_attachment_referencePtr.asFunction<void Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_dereference(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_dereference(
      self,
    );
  }

  late final _spine_mesh_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment)>>('spine_mesh_attachment_dereference');
  late final _spine_mesh_attachment_dereference =
      _spine_mesh_attachment_dereferencePtr.asFunction<void Function(spine_mesh_attachment)>();

  spine_rtti spine_mesh_attachment_rtti() {
    return _spine_mesh_attachment_rtti();
  }

  late final _spine_mesh_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_mesh_attachment_rtti');
  late final _spine_mesh_attachment_rtti = _spine_mesh_attachment_rttiPtr.asFunction<spine_rtti Function()>();

  spine_path_attachment spine_path_attachment_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_path_attachment_create(
      name,
    );
  }

  late final _spine_path_attachment_createPtr =
      _lookup<ffi.NativeFunction<spine_path_attachment Function(ffi.Pointer<ffi.Char>)>>(
          'spine_path_attachment_create');
  late final _spine_path_attachment_create =
      _spine_path_attachment_createPtr.asFunction<spine_path_attachment Function(ffi.Pointer<ffi.Char>)>();

  void spine_path_attachment_dispose(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_dispose(
      self,
    );
  }

  late final _spine_path_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment)>>('spine_path_attachment_dispose');
  late final _spine_path_attachment_dispose =
      _spine_path_attachment_disposePtr.asFunction<void Function(spine_path_attachment)>();

  spine_rtti spine_path_attachment_get_rtti(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_rtti(
      self,
    );
  }

  late final _spine_path_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_path_attachment)>>('spine_path_attachment_get_rtti');
  late final _spine_path_attachment_get_rtti =
      _spine_path_attachment_get_rttiPtr.asFunction<spine_rtti Function(spine_path_attachment)>();

  /// The length in the setup pose from the start of the path to the end of each
  /// curve.
  spine_array_float spine_path_attachment_get_lengths(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_lengths(
      self,
    );
  }

  late final _spine_path_attachment_get_lengthsPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_path_attachment)>>(
          'spine_path_attachment_get_lengths');
  late final _spine_path_attachment_get_lengths =
      _spine_path_attachment_get_lengthsPtr.asFunction<spine_array_float Function(spine_path_attachment)>();

  void spine_path_attachment_set_lengths(
    spine_path_attachment self,
    spine_array_float inValue,
  ) {
    return _spine_path_attachment_set_lengths(
      self,
      inValue,
    );
  }

  late final _spine_path_attachment_set_lengthsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, spine_array_float)>>(
          'spine_path_attachment_set_lengths');
  late final _spine_path_attachment_set_lengths =
      _spine_path_attachment_set_lengthsPtr.asFunction<void Function(spine_path_attachment, spine_array_float)>();

  bool spine_path_attachment_get_closed(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_closed(
      self,
    );
  }

  late final _spine_path_attachment_get_closedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_attachment)>>('spine_path_attachment_get_closed');
  late final _spine_path_attachment_get_closed =
      _spine_path_attachment_get_closedPtr.asFunction<bool Function(spine_path_attachment)>();

  void spine_path_attachment_set_closed(
    spine_path_attachment self,
    bool inValue,
  ) {
    return _spine_path_attachment_set_closed(
      self,
      inValue,
    );
  }

  late final _spine_path_attachment_set_closedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, ffi.Bool)>>(
          'spine_path_attachment_set_closed');
  late final _spine_path_attachment_set_closed =
      _spine_path_attachment_set_closedPtr.asFunction<void Function(spine_path_attachment, bool)>();

  bool spine_path_attachment_get_constant_speed(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_constant_speed(
      self,
    );
  }

  late final _spine_path_attachment_get_constant_speedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_attachment)>>('spine_path_attachment_get_constant_speed');
  late final _spine_path_attachment_get_constant_speed =
      _spine_path_attachment_get_constant_speedPtr.asFunction<bool Function(spine_path_attachment)>();

  void spine_path_attachment_set_constant_speed(
    spine_path_attachment self,
    bool inValue,
  ) {
    return _spine_path_attachment_set_constant_speed(
      self,
      inValue,
    );
  }

  late final _spine_path_attachment_set_constant_speedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, ffi.Bool)>>(
          'spine_path_attachment_set_constant_speed');
  late final _spine_path_attachment_set_constant_speed =
      _spine_path_attachment_set_constant_speedPtr.asFunction<void Function(spine_path_attachment, bool)>();

  spine_color spine_path_attachment_get_color(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_color(
      self,
    );
  }

  late final _spine_path_attachment_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_path_attachment)>>('spine_path_attachment_get_color');
  late final _spine_path_attachment_get_color =
      _spine_path_attachment_get_colorPtr.asFunction<spine_color Function(spine_path_attachment)>();

  spine_attachment spine_path_attachment_copy(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_copy(
      self,
    );
  }

  late final _spine_path_attachment_copyPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_path_attachment)>>('spine_path_attachment_copy');
  late final _spine_path_attachment_copy =
      _spine_path_attachment_copyPtr.asFunction<spine_attachment Function(spine_path_attachment)>();

  /// Transforms the attachment's local vertices to world coordinates. If the
  /// slot's SlotPose::getDeform() is not empty, it is used to deform the vertices.
  ///
  /// See https://esotericsoftware.com/spine-runtime-skeletons#World-transforms
  /// World transforms in the Spine Runtimes Guide.
  ///
  /// @param start The index of the first vertices value to transform. Each vertex has 2 values, x and y.
  /// @param count The number of world vertex values to output. Must be < = WorldVerticesLength - start.
  /// @param worldVertices The output world vertices. Must have a length >= offset + count * stride / 2.
  /// @param offset The worldVertices index to begin writing values.
  /// @param stride The number of worldVertices entries between the value pairs written.
  void spine_path_attachment_compute_world_vertices_1(
    spine_path_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    ffi.Pointer<ffi.Float> worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_path_attachment_compute_world_vertices_1(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_path_attachment_compute_world_vertices_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_attachment, spine_skeleton, spine_slot, ffi.Size, ffi.Size,
              ffi.Pointer<ffi.Float>, ffi.Size, ffi.Size)>>('spine_path_attachment_compute_world_vertices_1');
  late final _spine_path_attachment_compute_world_vertices_1 =
      _spine_path_attachment_compute_world_vertices_1Ptr.asFunction<
          void Function(
              spine_path_attachment, spine_skeleton, spine_slot, int, int, ffi.Pointer<ffi.Float>, int, int)>();

  void spine_path_attachment_compute_world_vertices_2(
    spine_path_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    spine_array_float worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_path_attachment_compute_world_vertices_2(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_path_attachment_compute_world_vertices_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_attachment, spine_skeleton, spine_slot, ffi.Size, ffi.Size, spine_array_float,
              ffi.Size, ffi.Size)>>('spine_path_attachment_compute_world_vertices_2');
  late final _spine_path_attachment_compute_world_vertices_2 =
      _spine_path_attachment_compute_world_vertices_2Ptr.asFunction<
          void Function(spine_path_attachment, spine_skeleton, spine_slot, int, int, spine_array_float, int, int)>();

  /// Gets a unique ID for this attachment.
  int spine_path_attachment_get_id(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_id(
      self,
    );
  }

  late final _spine_path_attachment_get_idPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_path_attachment)>>('spine_path_attachment_get_id');
  late final _spine_path_attachment_get_id =
      _spine_path_attachment_get_idPtr.asFunction<int Function(spine_path_attachment)>();

  spine_array_int spine_path_attachment_get_bones(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_bones(
      self,
    );
  }

  late final _spine_path_attachment_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_int Function(spine_path_attachment)>>('spine_path_attachment_get_bones');
  late final _spine_path_attachment_get_bones =
      _spine_path_attachment_get_bonesPtr.asFunction<spine_array_int Function(spine_path_attachment)>();

  void spine_path_attachment_set_bones(
    spine_path_attachment self,
    spine_array_int bones,
  ) {
    return _spine_path_attachment_set_bones(
      self,
      bones,
    );
  }

  late final _spine_path_attachment_set_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, spine_array_int)>>(
          'spine_path_attachment_set_bones');
  late final _spine_path_attachment_set_bones =
      _spine_path_attachment_set_bonesPtr.asFunction<void Function(spine_path_attachment, spine_array_int)>();

  spine_array_float spine_path_attachment_get_vertices(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_vertices(
      self,
    );
  }

  late final _spine_path_attachment_get_verticesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_path_attachment)>>(
          'spine_path_attachment_get_vertices');
  late final _spine_path_attachment_get_vertices =
      _spine_path_attachment_get_verticesPtr.asFunction<spine_array_float Function(spine_path_attachment)>();

  void spine_path_attachment_set_vertices(
    spine_path_attachment self,
    spine_array_float vertices,
  ) {
    return _spine_path_attachment_set_vertices(
      self,
      vertices,
    );
  }

  late final _spine_path_attachment_set_verticesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, spine_array_float)>>(
          'spine_path_attachment_set_vertices');
  late final _spine_path_attachment_set_vertices =
      _spine_path_attachment_set_verticesPtr.asFunction<void Function(spine_path_attachment, spine_array_float)>();

  int spine_path_attachment_get_world_vertices_length(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_world_vertices_length(
      self,
    );
  }

  late final _spine_path_attachment_get_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_path_attachment)>>(
          'spine_path_attachment_get_world_vertices_length');
  late final _spine_path_attachment_get_world_vertices_length =
      _spine_path_attachment_get_world_vertices_lengthPtr.asFunction<int Function(spine_path_attachment)>();

  void spine_path_attachment_set_world_vertices_length(
    spine_path_attachment self,
    int inValue,
  ) {
    return _spine_path_attachment_set_world_vertices_length(
      self,
      inValue,
    );
  }

  late final _spine_path_attachment_set_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, ffi.Size)>>(
          'spine_path_attachment_set_world_vertices_length');
  late final _spine_path_attachment_set_world_vertices_length =
      _spine_path_attachment_set_world_vertices_lengthPtr.asFunction<void Function(spine_path_attachment, int)>();

  spine_attachment spine_path_attachment_get_timeline_attachment(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_timeline_attachment(
      self,
    );
  }

  late final _spine_path_attachment_get_timeline_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_path_attachment)>>(
          'spine_path_attachment_get_timeline_attachment');
  late final _spine_path_attachment_get_timeline_attachment =
      _spine_path_attachment_get_timeline_attachmentPtr.asFunction<spine_attachment Function(spine_path_attachment)>();

  void spine_path_attachment_set_timeline_attachment(
    spine_path_attachment self,
    spine_attachment attachment,
  ) {
    return _spine_path_attachment_set_timeline_attachment(
      self,
      attachment,
    );
  }

  late final _spine_path_attachment_set_timeline_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, spine_attachment)>>(
          'spine_path_attachment_set_timeline_attachment');
  late final _spine_path_attachment_set_timeline_attachment = _spine_path_attachment_set_timeline_attachmentPtr
      .asFunction<void Function(spine_path_attachment, spine_attachment)>();

  void spine_path_attachment_copy_to(
    spine_path_attachment self,
    spine_vertex_attachment other,
  ) {
    return _spine_path_attachment_copy_to(
      self,
      other,
    );
  }

  late final _spine_path_attachment_copy_toPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, spine_vertex_attachment)>>(
          'spine_path_attachment_copy_to');
  late final _spine_path_attachment_copy_to =
      _spine_path_attachment_copy_toPtr.asFunction<void Function(spine_path_attachment, spine_vertex_attachment)>();

  ffi.Pointer<ffi.Char> spine_path_attachment_get_name(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_name(
      self,
    );
  }

  late final _spine_path_attachment_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_path_attachment)>>(
          'spine_path_attachment_get_name');
  late final _spine_path_attachment_get_name =
      _spine_path_attachment_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_path_attachment)>();

  int spine_path_attachment_get_ref_count(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_path_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_path_attachment)>>('spine_path_attachment_get_ref_count');
  late final _spine_path_attachment_get_ref_count =
      _spine_path_attachment_get_ref_countPtr.asFunction<int Function(spine_path_attachment)>();

  void spine_path_attachment_reference(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_reference(
      self,
    );
  }

  late final _spine_path_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment)>>('spine_path_attachment_reference');
  late final _spine_path_attachment_reference =
      _spine_path_attachment_referencePtr.asFunction<void Function(spine_path_attachment)>();

  void spine_path_attachment_dereference(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_dereference(
      self,
    );
  }

  late final _spine_path_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment)>>('spine_path_attachment_dereference');
  late final _spine_path_attachment_dereference =
      _spine_path_attachment_dereferencePtr.asFunction<void Function(spine_path_attachment)>();

  spine_rtti spine_path_attachment_rtti() {
    return _spine_path_attachment_rtti();
  }

  late final _spine_path_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_path_attachment_rtti');
  late final _spine_path_attachment_rtti = _spine_path_attachment_rttiPtr.asFunction<spine_rtti Function()>();

  spine_path_constraint spine_path_constraint_create(
    spine_path_constraint_data data,
    spine_skeleton skeleton,
  ) {
    return _spine_path_constraint_create(
      data,
      skeleton,
    );
  }

  late final _spine_path_constraint_createPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint Function(spine_path_constraint_data, spine_skeleton)>>(
          'spine_path_constraint_create');
  late final _spine_path_constraint_create = _spine_path_constraint_createPtr
      .asFunction<spine_path_constraint Function(spine_path_constraint_data, spine_skeleton)>();

  void spine_path_constraint_dispose(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_dispose(
      self,
    );
  }

  late final _spine_path_constraint_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint)>>('spine_path_constraint_dispose');
  late final _spine_path_constraint_dispose =
      _spine_path_constraint_disposePtr.asFunction<void Function(spine_path_constraint)>();

  spine_rtti spine_path_constraint_get_rtti(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_get_rtti(
      self,
    );
  }

  late final _spine_path_constraint_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_path_constraint)>>('spine_path_constraint_get_rtti');
  late final _spine_path_constraint_get_rtti =
      _spine_path_constraint_get_rttiPtr.asFunction<spine_rtti Function(spine_path_constraint)>();

  spine_path_constraint spine_path_constraint_copy(
    spine_path_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_path_constraint_copy(
      self,
      skeleton,
    );
  }

  late final _spine_path_constraint_copyPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint Function(spine_path_constraint, spine_skeleton)>>(
          'spine_path_constraint_copy');
  late final _spine_path_constraint_copy = _spine_path_constraint_copyPtr
      .asFunction<spine_path_constraint Function(spine_path_constraint, spine_skeleton)>();

  /// Applies the constraint to the constrained bones.
  void spine_path_constraint_update(
    spine_path_constraint self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_path_constraint_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_path_constraint_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, spine_skeleton, ffi.Int32)>>(
          'spine_path_constraint_update');
  late final _spine_path_constraint_update =
      _spine_path_constraint_updatePtr.asFunction<void Function(spine_path_constraint, spine_skeleton, int)>();

  void spine_path_constraint_sort(
    spine_path_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_path_constraint_sort(
      self,
      skeleton,
    );
  }

  late final _spine_path_constraint_sortPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, spine_skeleton)>>(
          'spine_path_constraint_sort');
  late final _spine_path_constraint_sort =
      _spine_path_constraint_sortPtr.asFunction<void Function(spine_path_constraint, spine_skeleton)>();

  bool spine_path_constraint_is_source_active(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_is_source_active(
      self,
    );
  }

  late final _spine_path_constraint_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_constraint)>>('spine_path_constraint_is_source_active');
  late final _spine_path_constraint_is_source_active =
      _spine_path_constraint_is_source_activePtr.asFunction<bool Function(spine_path_constraint)>();

  /// The bones that will be modified by this path constraint.
  spine_array_bone_pose spine_path_constraint_get_bones(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_get_bones(
      self,
    );
  }

  late final _spine_path_constraint_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_bone_pose Function(spine_path_constraint)>>(
          'spine_path_constraint_get_bones');
  late final _spine_path_constraint_get_bones =
      _spine_path_constraint_get_bonesPtr.asFunction<spine_array_bone_pose Function(spine_path_constraint)>();

  /// The slot whose path attachment will be used to constrained the bones.
  spine_slot spine_path_constraint_get_slot(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_get_slot(
      self,
    );
  }

  late final _spine_path_constraint_get_slotPtr =
      _lookup<ffi.NativeFunction<spine_slot Function(spine_path_constraint)>>('spine_path_constraint_get_slot');
  late final _spine_path_constraint_get_slot =
      _spine_path_constraint_get_slotPtr.asFunction<spine_slot Function(spine_path_constraint)>();

  void spine_path_constraint_set_slot(
    spine_path_constraint self,
    spine_slot slot,
  ) {
    return _spine_path_constraint_set_slot(
      self,
      slot,
    );
  }

  late final _spine_path_constraint_set_slotPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, spine_slot)>>(
          'spine_path_constraint_set_slot');
  late final _spine_path_constraint_set_slot =
      _spine_path_constraint_set_slotPtr.asFunction<void Function(spine_path_constraint, spine_slot)>();

  spine_path_constraint_data spine_path_constraint_get_data(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_get_data(
      self,
    );
  }

  late final _spine_path_constraint_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_data Function(spine_path_constraint)>>(
          'spine_path_constraint_get_data');
  late final _spine_path_constraint_get_data =
      _spine_path_constraint_get_dataPtr.asFunction<spine_path_constraint_data Function(spine_path_constraint)>();

  spine_path_constraint_pose spine_path_constraint_get_pose(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_get_pose(
      self,
    );
  }

  late final _spine_path_constraint_get_posePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_pose Function(spine_path_constraint)>>(
          'spine_path_constraint_get_pose');
  late final _spine_path_constraint_get_pose =
      _spine_path_constraint_get_posePtr.asFunction<spine_path_constraint_pose Function(spine_path_constraint)>();

  spine_path_constraint_pose spine_path_constraint_get_applied_pose(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_get_applied_pose(
      self,
    );
  }

  late final _spine_path_constraint_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_pose Function(spine_path_constraint)>>(
          'spine_path_constraint_get_applied_pose');
  late final _spine_path_constraint_get_applied_pose = _spine_path_constraint_get_applied_posePtr
      .asFunction<spine_path_constraint_pose Function(spine_path_constraint)>();

  void spine_path_constraint_reset_constrained(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_reset_constrained(
      self,
    );
  }

  late final _spine_path_constraint_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint)>>('spine_path_constraint_reset_constrained');
  late final _spine_path_constraint_reset_constrained =
      _spine_path_constraint_reset_constrainedPtr.asFunction<void Function(spine_path_constraint)>();

  void spine_path_constraint_constrained(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_constrained(
      self,
    );
  }

  late final _spine_path_constraint_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint)>>('spine_path_constraint_constrained');
  late final _spine_path_constraint_constrained =
      _spine_path_constraint_constrainedPtr.asFunction<void Function(spine_path_constraint)>();

  bool spine_path_constraint_is_pose_equal_to_applied(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_path_constraint_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_constraint)>>(
          'spine_path_constraint_is_pose_equal_to_applied');
  late final _spine_path_constraint_is_pose_equal_to_applied =
      _spine_path_constraint_is_pose_equal_to_appliedPtr.asFunction<bool Function(spine_path_constraint)>();

  bool spine_path_constraint_is_active(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_is_active(
      self,
    );
  }

  late final _spine_path_constraint_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_constraint)>>('spine_path_constraint_is_active');
  late final _spine_path_constraint_is_active =
      _spine_path_constraint_is_activePtr.asFunction<bool Function(spine_path_constraint)>();

  void spine_path_constraint_set_active(
    spine_path_constraint self,
    bool active,
  ) {
    return _spine_path_constraint_set_active(
      self,
      active,
    );
  }

  late final _spine_path_constraint_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, ffi.Bool)>>(
          'spine_path_constraint_set_active');
  late final _spine_path_constraint_set_active =
      _spine_path_constraint_set_activePtr.asFunction<void Function(spine_path_constraint, bool)>();

  spine_rtti spine_path_constraint_rtti() {
    return _spine_path_constraint_rtti();
  }

  late final _spine_path_constraint_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_path_constraint_rtti');
  late final _spine_path_constraint_rtti = _spine_path_constraint_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_path_constraint_base_dispose(
    spine_path_constraint_base self,
  ) {
    return _spine_path_constraint_base_dispose(
      self,
    );
  }

  late final _spine_path_constraint_base_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_base)>>('spine_path_constraint_base_dispose');
  late final _spine_path_constraint_base_dispose =
      _spine_path_constraint_base_disposePtr.asFunction<void Function(spine_path_constraint_base)>();

  spine_path_constraint_data spine_path_constraint_base_get_data(
    spine_path_constraint_base self,
  ) {
    return _spine_path_constraint_base_get_data(
      self,
    );
  }

  late final _spine_path_constraint_base_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_data Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_get_data');
  late final _spine_path_constraint_base_get_data = _spine_path_constraint_base_get_dataPtr
      .asFunction<spine_path_constraint_data Function(spine_path_constraint_base)>();

  spine_path_constraint_pose spine_path_constraint_base_get_pose(
    spine_path_constraint_base self,
  ) {
    return _spine_path_constraint_base_get_pose(
      self,
    );
  }

  late final _spine_path_constraint_base_get_posePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_pose Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_get_pose');
  late final _spine_path_constraint_base_get_pose = _spine_path_constraint_base_get_posePtr
      .asFunction<spine_path_constraint_pose Function(spine_path_constraint_base)>();

  spine_path_constraint_pose spine_path_constraint_base_get_applied_pose(
    spine_path_constraint_base self,
  ) {
    return _spine_path_constraint_base_get_applied_pose(
      self,
    );
  }

  late final _spine_path_constraint_base_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_pose Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_get_applied_pose');
  late final _spine_path_constraint_base_get_applied_pose = _spine_path_constraint_base_get_applied_posePtr
      .asFunction<spine_path_constraint_pose Function(spine_path_constraint_base)>();

  void spine_path_constraint_base_reset_constrained(
    spine_path_constraint_base self,
  ) {
    return _spine_path_constraint_base_reset_constrained(
      self,
    );
  }

  late final _spine_path_constraint_base_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_reset_constrained');
  late final _spine_path_constraint_base_reset_constrained =
      _spine_path_constraint_base_reset_constrainedPtr.asFunction<void Function(spine_path_constraint_base)>();

  void spine_path_constraint_base_constrained(
    spine_path_constraint_base self,
  ) {
    return _spine_path_constraint_base_constrained(
      self,
    );
  }

  late final _spine_path_constraint_base_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_constrained');
  late final _spine_path_constraint_base_constrained =
      _spine_path_constraint_base_constrainedPtr.asFunction<void Function(spine_path_constraint_base)>();

  bool spine_path_constraint_base_is_pose_equal_to_applied(
    spine_path_constraint_base self,
  ) {
    return _spine_path_constraint_base_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_path_constraint_base_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_is_pose_equal_to_applied');
  late final _spine_path_constraint_base_is_pose_equal_to_applied =
      _spine_path_constraint_base_is_pose_equal_to_appliedPtr.asFunction<bool Function(spine_path_constraint_base)>();

  bool spine_path_constraint_base_is_active(
    spine_path_constraint_base self,
  ) {
    return _spine_path_constraint_base_is_active(
      self,
    );
  }

  late final _spine_path_constraint_base_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_is_active');
  late final _spine_path_constraint_base_is_active =
      _spine_path_constraint_base_is_activePtr.asFunction<bool Function(spine_path_constraint_base)>();

  void spine_path_constraint_base_set_active(
    spine_path_constraint_base self,
    bool active,
  ) {
    return _spine_path_constraint_base_set_active(
      self,
      active,
    );
  }

  late final _spine_path_constraint_base_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_base, ffi.Bool)>>(
          'spine_path_constraint_base_set_active');
  late final _spine_path_constraint_base_set_active =
      _spine_path_constraint_base_set_activePtr.asFunction<void Function(spine_path_constraint_base, bool)>();

  spine_rtti spine_path_constraint_base_get_rtti(
    spine_path_constraint_base self,
  ) {
    return _spine_path_constraint_base_get_rtti(
      self,
    );
  }

  late final _spine_path_constraint_base_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_get_rtti');
  late final _spine_path_constraint_base_get_rtti =
      _spine_path_constraint_base_get_rttiPtr.asFunction<spine_rtti Function(spine_path_constraint_base)>();

  void spine_path_constraint_base_sort(
    spine_path_constraint_base self,
    spine_skeleton skeleton,
  ) {
    return _spine_path_constraint_base_sort(
      self,
      skeleton,
    );
  }

  late final _spine_path_constraint_base_sortPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_base, spine_skeleton)>>(
          'spine_path_constraint_base_sort');
  late final _spine_path_constraint_base_sort =
      _spine_path_constraint_base_sortPtr.asFunction<void Function(spine_path_constraint_base, spine_skeleton)>();

  bool spine_path_constraint_base_is_source_active(
    spine_path_constraint_base self,
  ) {
    return _spine_path_constraint_base_is_source_active(
      self,
    );
  }

  late final _spine_path_constraint_base_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_constraint_base)>>(
          'spine_path_constraint_base_is_source_active');
  late final _spine_path_constraint_base_is_source_active =
      _spine_path_constraint_base_is_source_activePtr.asFunction<bool Function(spine_path_constraint_base)>();

  /// Inherited from Update
  void spine_path_constraint_base_update(
    spine_path_constraint_base self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_path_constraint_base_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_path_constraint_base_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_base, spine_skeleton, ffi.Int32)>>(
          'spine_path_constraint_base_update');
  late final _spine_path_constraint_base_update = _spine_path_constraint_base_updatePtr
      .asFunction<void Function(spine_path_constraint_base, spine_skeleton, int)>();

  spine_rtti spine_path_constraint_base_rtti() {
    return _spine_path_constraint_base_rtti();
  }

  late final _spine_path_constraint_base_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_path_constraint_base_rtti');
  late final _spine_path_constraint_base_rtti = _spine_path_constraint_base_rttiPtr.asFunction<spine_rtti Function()>();

  spine_path_constraint_data spine_path_constraint_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_path_constraint_data_create(
      name,
    );
  }

  late final _spine_path_constraint_data_createPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_data Function(ffi.Pointer<ffi.Char>)>>(
          'spine_path_constraint_data_create');
  late final _spine_path_constraint_data_create =
      _spine_path_constraint_data_createPtr.asFunction<spine_path_constraint_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_path_constraint_data_dispose(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_dispose(
      self,
    );
  }

  late final _spine_path_constraint_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data)>>('spine_path_constraint_data_dispose');
  late final _spine_path_constraint_data_dispose =
      _spine_path_constraint_data_disposePtr.asFunction<void Function(spine_path_constraint_data)>();

  spine_rtti spine_path_constraint_data_get_rtti(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_rtti(
      self,
    );
  }

  late final _spine_path_constraint_data_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_path_constraint_data)>>(
          'spine_path_constraint_data_get_rtti');
  late final _spine_path_constraint_data_get_rtti =
      _spine_path_constraint_data_get_rttiPtr.asFunction<spine_rtti Function(spine_path_constraint_data)>();

  spine_constraint spine_path_constraint_data_create_method(
    spine_path_constraint_data self,
    spine_skeleton skeleton,
  ) {
    return _spine_path_constraint_data_create_method(
      self,
      skeleton,
    );
  }

  late final _spine_path_constraint_data_create_methodPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_path_constraint_data, spine_skeleton)>>(
          'spine_path_constraint_data_create_method');
  late final _spine_path_constraint_data_create_method = _spine_path_constraint_data_create_methodPtr
      .asFunction<spine_constraint Function(spine_path_constraint_data, spine_skeleton)>();

  /// The bones that will be modified by this path constraint.
  spine_array_bone_data spine_path_constraint_data_get_bones(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_bones(
      self,
    );
  }

  late final _spine_path_constraint_data_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_bone_data Function(spine_path_constraint_data)>>(
          'spine_path_constraint_data_get_bones');
  late final _spine_path_constraint_data_get_bones =
      _spine_path_constraint_data_get_bonesPtr.asFunction<spine_array_bone_data Function(spine_path_constraint_data)>();

  /// The slot whose path attachment will be used to constrained the bones.
  spine_slot_data spine_path_constraint_data_get_slot(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_slot(
      self,
    );
  }

  late final _spine_path_constraint_data_get_slotPtr =
      _lookup<ffi.NativeFunction<spine_slot_data Function(spine_path_constraint_data)>>(
          'spine_path_constraint_data_get_slot');
  late final _spine_path_constraint_data_get_slot =
      _spine_path_constraint_data_get_slotPtr.asFunction<spine_slot_data Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_slot(
    spine_path_constraint_data self,
    spine_slot_data slot,
  ) {
    return _spine_path_constraint_data_set_slot(
      self,
      slot,
    );
  }

  late final _spine_path_constraint_data_set_slotPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, spine_slot_data)>>(
          'spine_path_constraint_data_set_slot');
  late final _spine_path_constraint_data_set_slot =
      _spine_path_constraint_data_set_slotPtr.asFunction<void Function(spine_path_constraint_data, spine_slot_data)>();

  /// The mode for positioning the first bone on the path.
  int spine_path_constraint_data_get_position_mode(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_position_mode(
      self,
    );
  }

  late final _spine_path_constraint_data_get_position_modePtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint_data)>>(
          'spine_path_constraint_data_get_position_mode');
  late final _spine_path_constraint_data_get_position_mode =
      _spine_path_constraint_data_get_position_modePtr.asFunction<int Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_position_mode(
    spine_path_constraint_data self,
    int positionMode,
  ) {
    return _spine_path_constraint_data_set_position_mode(
      self,
      positionMode,
    );
  }

  late final _spine_path_constraint_data_set_position_modePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Int32)>>(
          'spine_path_constraint_data_set_position_mode');
  late final _spine_path_constraint_data_set_position_mode =
      _spine_path_constraint_data_set_position_modePtr.asFunction<void Function(spine_path_constraint_data, int)>();

  /// The mode for positioning the bones after the first bone on the path.
  int spine_path_constraint_data_get_spacing_mode(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_spacing_mode(
      self,
    );
  }

  late final _spine_path_constraint_data_get_spacing_modePtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint_data)>>(
          'spine_path_constraint_data_get_spacing_mode');
  late final _spine_path_constraint_data_get_spacing_mode =
      _spine_path_constraint_data_get_spacing_modePtr.asFunction<int Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_spacing_mode(
    spine_path_constraint_data self,
    int spacingMode,
  ) {
    return _spine_path_constraint_data_set_spacing_mode(
      self,
      spacingMode,
    );
  }

  late final _spine_path_constraint_data_set_spacing_modePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Int32)>>(
          'spine_path_constraint_data_set_spacing_mode');
  late final _spine_path_constraint_data_set_spacing_mode =
      _spine_path_constraint_data_set_spacing_modePtr.asFunction<void Function(spine_path_constraint_data, int)>();

  /// The mode for adjusting the rotation of the bones.
  int spine_path_constraint_data_get_rotate_mode(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_rotate_mode(
      self,
    );
  }

  late final _spine_path_constraint_data_get_rotate_modePtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint_data)>>(
          'spine_path_constraint_data_get_rotate_mode');
  late final _spine_path_constraint_data_get_rotate_mode =
      _spine_path_constraint_data_get_rotate_modePtr.asFunction<int Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_rotate_mode(
    spine_path_constraint_data self,
    int rotateMode,
  ) {
    return _spine_path_constraint_data_set_rotate_mode(
      self,
      rotateMode,
    );
  }

  late final _spine_path_constraint_data_set_rotate_modePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Int32)>>(
          'spine_path_constraint_data_set_rotate_mode');
  late final _spine_path_constraint_data_set_rotate_mode =
      _spine_path_constraint_data_set_rotate_modePtr.asFunction<void Function(spine_path_constraint_data, int)>();

  /// An offset added to the constrained bone rotation.
  double spine_path_constraint_data_get_offset_rotation(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_offset_rotation(
      self,
    );
  }

  late final _spine_path_constraint_data_get_offset_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_data)>>(
          'spine_path_constraint_data_get_offset_rotation');
  late final _spine_path_constraint_data_get_offset_rotation =
      _spine_path_constraint_data_get_offset_rotationPtr.asFunction<double Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_offset_rotation(
    spine_path_constraint_data self,
    double offsetRotation,
  ) {
    return _spine_path_constraint_data_set_offset_rotation(
      self,
      offsetRotation,
    );
  }

  late final _spine_path_constraint_data_set_offset_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Float)>>(
          'spine_path_constraint_data_set_offset_rotation');
  late final _spine_path_constraint_data_set_offset_rotation = _spine_path_constraint_data_set_offset_rotationPtr
      .asFunction<void Function(spine_path_constraint_data, double)>();

  /// Resolve ambiguity by forwarding to PosedData's implementation
  ffi.Pointer<ffi.Char> spine_path_constraint_data_get_name(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_name(
      self,
    );
  }

  late final _spine_path_constraint_data_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_path_constraint_data)>>(
          'spine_path_constraint_data_get_name');
  late final _spine_path_constraint_data_get_name =
      _spine_path_constraint_data_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_path_constraint_data)>();

  bool spine_path_constraint_data_get_skin_required(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_skin_required(
      self,
    );
  }

  late final _spine_path_constraint_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_constraint_data)>>(
          'spine_path_constraint_data_get_skin_required');
  late final _spine_path_constraint_data_get_skin_required =
      _spine_path_constraint_data_get_skin_requiredPtr.asFunction<bool Function(spine_path_constraint_data)>();

  spine_path_constraint_pose spine_path_constraint_data_get_setup_pose(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_setup_pose(
      self,
    );
  }

  late final _spine_path_constraint_data_get_setup_posePtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_pose Function(spine_path_constraint_data)>>(
          'spine_path_constraint_data_get_setup_pose');
  late final _spine_path_constraint_data_get_setup_pose = _spine_path_constraint_data_get_setup_posePtr
      .asFunction<spine_path_constraint_pose Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_skin_required(
    spine_path_constraint_data self,
    bool skinRequired,
  ) {
    return _spine_path_constraint_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_path_constraint_data_set_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Bool)>>(
          'spine_path_constraint_data_set_skin_required');
  late final _spine_path_constraint_data_set_skin_required =
      _spine_path_constraint_data_set_skin_requiredPtr.asFunction<void Function(spine_path_constraint_data, bool)>();

  spine_rtti spine_path_constraint_data_rtti() {
    return _spine_path_constraint_data_rtti();
  }

  late final _spine_path_constraint_data_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_path_constraint_data_rtti');
  late final _spine_path_constraint_data_rtti = _spine_path_constraint_data_rttiPtr.asFunction<spine_rtti Function()>();

  spine_path_constraint_mix_timeline spine_path_constraint_mix_timeline_create(
    int frameCount,
    int bezierCount,
    int constraintIndex,
  ) {
    return _spine_path_constraint_mix_timeline_create(
      frameCount,
      bezierCount,
      constraintIndex,
    );
  }

  late final _spine_path_constraint_mix_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_mix_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_path_constraint_mix_timeline_create');
  late final _spine_path_constraint_mix_timeline_create = _spine_path_constraint_mix_timeline_createPtr
      .asFunction<spine_path_constraint_mix_timeline Function(int, int, int)>();

  void spine_path_constraint_mix_timeline_dispose(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_dispose(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_mix_timeline)>>(
          'spine_path_constraint_mix_timeline_dispose');
  late final _spine_path_constraint_mix_timeline_dispose =
      _spine_path_constraint_mix_timeline_disposePtr.asFunction<void Function(spine_path_constraint_mix_timeline)>();

  spine_rtti spine_path_constraint_mix_timeline_get_rtti(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_rtti(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_path_constraint_mix_timeline)>>(
          'spine_path_constraint_mix_timeline_get_rtti');
  late final _spine_path_constraint_mix_timeline_get_rtti = _spine_path_constraint_mix_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_path_constraint_mix_timeline)>();

  void spine_path_constraint_mix_timeline_apply(
    spine_path_constraint_mix_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_path_constraint_mix_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_path_constraint_mix_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_mix_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event,
              ffi.Float, ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_path_constraint_mix_timeline_apply');
  late final _spine_path_constraint_mix_timeline_apply = _spine_path_constraint_mix_timeline_applyPtr.asFunction<
      void Function(spine_path_constraint_mix_timeline, spine_skeleton, double, double, spine_array_event, double, int,
          int, bool)>();

  /// Sets the time and color for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_path_constraint_mix_timeline_set_frame(
    spine_path_constraint_mix_timeline self,
    int frame,
    double time,
    double mixRotate,
    double mixX,
    double mixY,
  ) {
    return _spine_path_constraint_mix_timeline_set_frame(
      self,
      frame,
      time,
      mixRotate,
      mixX,
      mixY,
    );
  }

  late final _spine_path_constraint_mix_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_mix_timeline, ffi.Int, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_path_constraint_mix_timeline_set_frame');
  late final _spine_path_constraint_mix_timeline_set_frame = _spine_path_constraint_mix_timeline_set_framePtr
      .asFunction<void Function(spine_path_constraint_mix_timeline, int, double, double, double, double)>();

  int spine_path_constraint_mix_timeline_get_constraint_index(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_path_constraint_mix_timeline)>>(
          'spine_path_constraint_mix_timeline_get_constraint_index');
  late final _spine_path_constraint_mix_timeline_get_constraint_index =
      _spine_path_constraint_mix_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_path_constraint_mix_timeline)>();

  void spine_path_constraint_mix_timeline_set_constraint_index(
    spine_path_constraint_mix_timeline self,
    int inValue,
  ) {
    return _spine_path_constraint_mix_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_path_constraint_mix_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_mix_timeline, ffi.Int)>>(
          'spine_path_constraint_mix_timeline_set_constraint_index');
  late final _spine_path_constraint_mix_timeline_set_constraint_index =
      _spine_path_constraint_mix_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_path_constraint_mix_timeline, int)>();

  void spine_path_constraint_mix_timeline_set_linear(
    spine_path_constraint_mix_timeline self,
    int frame,
  ) {
    return _spine_path_constraint_mix_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_path_constraint_mix_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_mix_timeline, ffi.Size)>>(
          'spine_path_constraint_mix_timeline_set_linear');
  late final _spine_path_constraint_mix_timeline_set_linear = _spine_path_constraint_mix_timeline_set_linearPtr
      .asFunction<void Function(spine_path_constraint_mix_timeline, int)>();

  void spine_path_constraint_mix_timeline_set_stepped(
    spine_path_constraint_mix_timeline self,
    int frame,
  ) {
    return _spine_path_constraint_mix_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_path_constraint_mix_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_mix_timeline, ffi.Size)>>(
          'spine_path_constraint_mix_timeline_set_stepped');
  late final _spine_path_constraint_mix_timeline_set_stepped = _spine_path_constraint_mix_timeline_set_steppedPtr
      .asFunction<void Function(spine_path_constraint_mix_timeline, int)>();

  void spine_path_constraint_mix_timeline_set_bezier(
    spine_path_constraint_mix_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_path_constraint_mix_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_path_constraint_mix_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_constraint_mix_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_path_constraint_mix_timeline_set_bezier');
  late final _spine_path_constraint_mix_timeline_set_bezier =
      _spine_path_constraint_mix_timeline_set_bezierPtr.asFunction<
          void Function(spine_path_constraint_mix_timeline, int, int, double, double, double, double, double, double,
              double, double, double)>();

  double spine_path_constraint_mix_timeline_get_bezier_value(
    spine_path_constraint_mix_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_path_constraint_mix_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_path_constraint_mix_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_path_constraint_mix_timeline_get_bezier_value');
  late final _spine_path_constraint_mix_timeline_get_bezier_value =
      _spine_path_constraint_mix_timeline_get_bezier_valuePtr
          .asFunction<double Function(spine_path_constraint_mix_timeline, double, int, int, int)>();

  spine_array_float spine_path_constraint_mix_timeline_get_curves(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_curves(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_path_constraint_mix_timeline)>>(
          'spine_path_constraint_mix_timeline_get_curves');
  late final _spine_path_constraint_mix_timeline_get_curves = _spine_path_constraint_mix_timeline_get_curvesPtr
      .asFunction<spine_array_float Function(spine_path_constraint_mix_timeline)>();

  int spine_path_constraint_mix_timeline_get_frame_entries(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_path_constraint_mix_timeline)>>(
          'spine_path_constraint_mix_timeline_get_frame_entries');
  late final _spine_path_constraint_mix_timeline_get_frame_entries =
      _spine_path_constraint_mix_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_path_constraint_mix_timeline)>();

  int spine_path_constraint_mix_timeline_get_frame_count(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_path_constraint_mix_timeline)>>(
          'spine_path_constraint_mix_timeline_get_frame_count');
  late final _spine_path_constraint_mix_timeline_get_frame_count =
      _spine_path_constraint_mix_timeline_get_frame_countPtr
          .asFunction<int Function(spine_path_constraint_mix_timeline)>();

  spine_array_float spine_path_constraint_mix_timeline_get_frames(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_frames(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_path_constraint_mix_timeline)>>(
          'spine_path_constraint_mix_timeline_get_frames');
  late final _spine_path_constraint_mix_timeline_get_frames = _spine_path_constraint_mix_timeline_get_framesPtr
      .asFunction<spine_array_float Function(spine_path_constraint_mix_timeline)>();

  double spine_path_constraint_mix_timeline_get_duration(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_duration(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_mix_timeline)>>(
          'spine_path_constraint_mix_timeline_get_duration');
  late final _spine_path_constraint_mix_timeline_get_duration = _spine_path_constraint_mix_timeline_get_durationPtr
      .asFunction<double Function(spine_path_constraint_mix_timeline)>();

  spine_array_property_id spine_path_constraint_mix_timeline_get_property_ids(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_path_constraint_mix_timeline)>>(
          'spine_path_constraint_mix_timeline_get_property_ids');
  late final _spine_path_constraint_mix_timeline_get_property_ids =
      _spine_path_constraint_mix_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_path_constraint_mix_timeline)>();

  spine_rtti spine_path_constraint_mix_timeline_rtti() {
    return _spine_path_constraint_mix_timeline_rtti();
  }

  late final _spine_path_constraint_mix_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_path_constraint_mix_timeline_rtti');
  late final _spine_path_constraint_mix_timeline_rtti =
      _spine_path_constraint_mix_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_path_constraint_pose spine_path_constraint_pose_create() {
    return _spine_path_constraint_pose_create();
  }

  late final _spine_path_constraint_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_pose Function()>>('spine_path_constraint_pose_create');
  late final _spine_path_constraint_pose_create =
      _spine_path_constraint_pose_createPtr.asFunction<spine_path_constraint_pose Function()>();

  void spine_path_constraint_pose_dispose(
    spine_path_constraint_pose self,
  ) {
    return _spine_path_constraint_pose_dispose(
      self,
    );
  }

  late final _spine_path_constraint_pose_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_pose)>>('spine_path_constraint_pose_dispose');
  late final _spine_path_constraint_pose_dispose =
      _spine_path_constraint_pose_disposePtr.asFunction<void Function(spine_path_constraint_pose)>();

  void spine_path_constraint_pose_set(
    spine_path_constraint_pose self,
    spine_path_constraint_pose pose,
  ) {
    return _spine_path_constraint_pose_set(
      self,
      pose,
    );
  }

  late final _spine_path_constraint_pose_setPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_pose, spine_path_constraint_pose)>>(
          'spine_path_constraint_pose_set');
  late final _spine_path_constraint_pose_set = _spine_path_constraint_pose_setPtr
      .asFunction<void Function(spine_path_constraint_pose, spine_path_constraint_pose)>();

  /// The position along the path.
  double spine_path_constraint_pose_get_position(
    spine_path_constraint_pose self,
  ) {
    return _spine_path_constraint_pose_get_position(
      self,
    );
  }

  late final _spine_path_constraint_pose_get_positionPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_pose)>>(
          'spine_path_constraint_pose_get_position');
  late final _spine_path_constraint_pose_get_position =
      _spine_path_constraint_pose_get_positionPtr.asFunction<double Function(spine_path_constraint_pose)>();

  void spine_path_constraint_pose_set_position(
    spine_path_constraint_pose self,
    double position,
  ) {
    return _spine_path_constraint_pose_set_position(
      self,
      position,
    );
  }

  late final _spine_path_constraint_pose_set_positionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_pose, ffi.Float)>>(
          'spine_path_constraint_pose_set_position');
  late final _spine_path_constraint_pose_set_position =
      _spine_path_constraint_pose_set_positionPtr.asFunction<void Function(spine_path_constraint_pose, double)>();

  /// The spacing between bones.
  double spine_path_constraint_pose_get_spacing(
    spine_path_constraint_pose self,
  ) {
    return _spine_path_constraint_pose_get_spacing(
      self,
    );
  }

  late final _spine_path_constraint_pose_get_spacingPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_pose)>>(
          'spine_path_constraint_pose_get_spacing');
  late final _spine_path_constraint_pose_get_spacing =
      _spine_path_constraint_pose_get_spacingPtr.asFunction<double Function(spine_path_constraint_pose)>();

  void spine_path_constraint_pose_set_spacing(
    spine_path_constraint_pose self,
    double spacing,
  ) {
    return _spine_path_constraint_pose_set_spacing(
      self,
      spacing,
    );
  }

  late final _spine_path_constraint_pose_set_spacingPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_pose, ffi.Float)>>(
          'spine_path_constraint_pose_set_spacing');
  late final _spine_path_constraint_pose_set_spacing =
      _spine_path_constraint_pose_set_spacingPtr.asFunction<void Function(spine_path_constraint_pose, double)>();

  /// A percentage (0-1) that controls the mix between the constrained and
  /// unconstrained rotation.
  double spine_path_constraint_pose_get_mix_rotate(
    spine_path_constraint_pose self,
  ) {
    return _spine_path_constraint_pose_get_mix_rotate(
      self,
    );
  }

  late final _spine_path_constraint_pose_get_mix_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_pose)>>(
          'spine_path_constraint_pose_get_mix_rotate');
  late final _spine_path_constraint_pose_get_mix_rotate =
      _spine_path_constraint_pose_get_mix_rotatePtr.asFunction<double Function(spine_path_constraint_pose)>();

  void spine_path_constraint_pose_set_mix_rotate(
    spine_path_constraint_pose self,
    double mixRotate,
  ) {
    return _spine_path_constraint_pose_set_mix_rotate(
      self,
      mixRotate,
    );
  }

  late final _spine_path_constraint_pose_set_mix_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_pose, ffi.Float)>>(
          'spine_path_constraint_pose_set_mix_rotate');
  late final _spine_path_constraint_pose_set_mix_rotate =
      _spine_path_constraint_pose_set_mix_rotatePtr.asFunction<void Function(spine_path_constraint_pose, double)>();

  /// A percentage (0-1) that controls the mix between the constrained and
  /// unconstrained translation X.
  double spine_path_constraint_pose_get_mix_x(
    spine_path_constraint_pose self,
  ) {
    return _spine_path_constraint_pose_get_mix_x(
      self,
    );
  }

  late final _spine_path_constraint_pose_get_mix_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_pose)>>(
          'spine_path_constraint_pose_get_mix_x');
  late final _spine_path_constraint_pose_get_mix_x =
      _spine_path_constraint_pose_get_mix_xPtr.asFunction<double Function(spine_path_constraint_pose)>();

  void spine_path_constraint_pose_set_mix_x(
    spine_path_constraint_pose self,
    double mixX,
  ) {
    return _spine_path_constraint_pose_set_mix_x(
      self,
      mixX,
    );
  }

  late final _spine_path_constraint_pose_set_mix_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_pose, ffi.Float)>>(
          'spine_path_constraint_pose_set_mix_x');
  late final _spine_path_constraint_pose_set_mix_x =
      _spine_path_constraint_pose_set_mix_xPtr.asFunction<void Function(spine_path_constraint_pose, double)>();

  /// A percentage (0-1) that controls the mix between the constrained and
  /// unconstrained translation Y.
  double spine_path_constraint_pose_get_mix_y(
    spine_path_constraint_pose self,
  ) {
    return _spine_path_constraint_pose_get_mix_y(
      self,
    );
  }

  late final _spine_path_constraint_pose_get_mix_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_pose)>>(
          'spine_path_constraint_pose_get_mix_y');
  late final _spine_path_constraint_pose_get_mix_y =
      _spine_path_constraint_pose_get_mix_yPtr.asFunction<double Function(spine_path_constraint_pose)>();

  void spine_path_constraint_pose_set_mix_y(
    spine_path_constraint_pose self,
    double mixY,
  ) {
    return _spine_path_constraint_pose_set_mix_y(
      self,
      mixY,
    );
  }

  late final _spine_path_constraint_pose_set_mix_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_pose, ffi.Float)>>(
          'spine_path_constraint_pose_set_mix_y');
  late final _spine_path_constraint_pose_set_mix_y =
      _spine_path_constraint_pose_set_mix_yPtr.asFunction<void Function(spine_path_constraint_pose, double)>();

  spine_path_constraint_position_timeline spine_path_constraint_position_timeline_create(
    int frameCount,
    int bezierCount,
    int constraintIndex,
  ) {
    return _spine_path_constraint_position_timeline_create(
      frameCount,
      bezierCount,
      constraintIndex,
    );
  }

  late final _spine_path_constraint_position_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_position_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_path_constraint_position_timeline_create');
  late final _spine_path_constraint_position_timeline_create = _spine_path_constraint_position_timeline_createPtr
      .asFunction<spine_path_constraint_position_timeline Function(int, int, int)>();

  void spine_path_constraint_position_timeline_dispose(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_dispose(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_dispose');
  late final _spine_path_constraint_position_timeline_dispose = _spine_path_constraint_position_timeline_disposePtr
      .asFunction<void Function(spine_path_constraint_position_timeline)>();

  spine_rtti spine_path_constraint_position_timeline_get_rtti(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_rtti(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_get_rtti');
  late final _spine_path_constraint_position_timeline_get_rtti = _spine_path_constraint_position_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_path_constraint_position_timeline)>();

  void spine_path_constraint_position_timeline_apply(
    spine_path_constraint_position_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_path_constraint_position_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_path_constraint_position_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_constraint_position_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_path_constraint_position_timeline_apply');
  late final _spine_path_constraint_position_timeline_apply =
      _spine_path_constraint_position_timeline_applyPtr.asFunction<
          void Function(spine_path_constraint_position_timeline, spine_skeleton, double, double, spine_array_event,
              double, int, int, bool)>();

  int spine_path_constraint_position_timeline_get_constraint_index(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_get_constraint_index');
  late final _spine_path_constraint_position_timeline_get_constraint_index =
      _spine_path_constraint_position_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_path_constraint_position_timeline)>();

  void spine_path_constraint_position_timeline_set_constraint_index(
    spine_path_constraint_position_timeline self,
    int inValue,
  ) {
    return _spine_path_constraint_position_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_path_constraint_position_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_position_timeline, ffi.Int)>>(
          'spine_path_constraint_position_timeline_set_constraint_index');
  late final _spine_path_constraint_position_timeline_set_constraint_index =
      _spine_path_constraint_position_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_path_constraint_position_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_path_constraint_position_timeline_set_frame(
    spine_path_constraint_position_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_path_constraint_position_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_path_constraint_position_timeline_set_framePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_path_constraint_position_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
      'spine_path_constraint_position_timeline_set_frame');
  late final _spine_path_constraint_position_timeline_set_frame = _spine_path_constraint_position_timeline_set_framePtr
      .asFunction<void Function(spine_path_constraint_position_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_path_constraint_position_timeline_get_curve_value(
    spine_path_constraint_position_timeline self,
    double time,
  ) {
    return _spine_path_constraint_position_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_path_constraint_position_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_position_timeline, ffi.Float)>>(
          'spine_path_constraint_position_timeline_get_curve_value');
  late final _spine_path_constraint_position_timeline_get_curve_value =
      _spine_path_constraint_position_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_path_constraint_position_timeline, double)>();

  double spine_path_constraint_position_timeline_get_relative_value(
    spine_path_constraint_position_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_path_constraint_position_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_path_constraint_position_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_path_constraint_position_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_path_constraint_position_timeline_get_relative_value');
  late final _spine_path_constraint_position_timeline_get_relative_value =
      _spine_path_constraint_position_timeline_get_relative_valuePtr
          .asFunction<double Function(spine_path_constraint_position_timeline, double, double, int, double, double)>();

  double spine_path_constraint_position_timeline_get_absolute_value_1(
    spine_path_constraint_position_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_path_constraint_position_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_path_constraint_position_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_path_constraint_position_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_path_constraint_position_timeline_get_absolute_value_1');
  late final _spine_path_constraint_position_timeline_get_absolute_value_1 =
      _spine_path_constraint_position_timeline_get_absolute_value_1Ptr
          .asFunction<double Function(spine_path_constraint_position_timeline, double, double, int, double, double)>();

  double spine_path_constraint_position_timeline_get_absolute_value_2(
    spine_path_constraint_position_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_path_constraint_position_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_path_constraint_position_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_path_constraint_position_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_path_constraint_position_timeline_get_absolute_value_2');
  late final _spine_path_constraint_position_timeline_get_absolute_value_2 =
      _spine_path_constraint_position_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_path_constraint_position_timeline, double, double, int, double, double, double)>();

  double spine_path_constraint_position_timeline_get_scale_value(
    spine_path_constraint_position_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_path_constraint_position_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_path_constraint_position_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_path_constraint_position_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32,
              ffi.Float, ffi.Float)>>('spine_path_constraint_position_timeline_get_scale_value');
  late final _spine_path_constraint_position_timeline_get_scale_value =
      _spine_path_constraint_position_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_path_constraint_position_timeline, double, double, int, int, double, double)>();

  void spine_path_constraint_position_timeline_set_linear(
    spine_path_constraint_position_timeline self,
    int frame,
  ) {
    return _spine_path_constraint_position_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_path_constraint_position_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_position_timeline, ffi.Size)>>(
          'spine_path_constraint_position_timeline_set_linear');
  late final _spine_path_constraint_position_timeline_set_linear =
      _spine_path_constraint_position_timeline_set_linearPtr
          .asFunction<void Function(spine_path_constraint_position_timeline, int)>();

  void spine_path_constraint_position_timeline_set_stepped(
    spine_path_constraint_position_timeline self,
    int frame,
  ) {
    return _spine_path_constraint_position_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_path_constraint_position_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_position_timeline, ffi.Size)>>(
          'spine_path_constraint_position_timeline_set_stepped');
  late final _spine_path_constraint_position_timeline_set_stepped =
      _spine_path_constraint_position_timeline_set_steppedPtr
          .asFunction<void Function(spine_path_constraint_position_timeline, int)>();

  void spine_path_constraint_position_timeline_set_bezier(
    spine_path_constraint_position_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_path_constraint_position_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_path_constraint_position_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_constraint_position_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_path_constraint_position_timeline_set_bezier');
  late final _spine_path_constraint_position_timeline_set_bezier =
      _spine_path_constraint_position_timeline_set_bezierPtr.asFunction<
          void Function(spine_path_constraint_position_timeline, int, int, double, double, double, double, double,
              double, double, double, double)>();

  double spine_path_constraint_position_timeline_get_bezier_value(
    spine_path_constraint_position_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_path_constraint_position_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_path_constraint_position_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_path_constraint_position_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_path_constraint_position_timeline_get_bezier_value');
  late final _spine_path_constraint_position_timeline_get_bezier_value =
      _spine_path_constraint_position_timeline_get_bezier_valuePtr
          .asFunction<double Function(spine_path_constraint_position_timeline, double, int, int, int)>();

  spine_array_float spine_path_constraint_position_timeline_get_curves(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_curves(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_get_curves');
  late final _spine_path_constraint_position_timeline_get_curves =
      _spine_path_constraint_position_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_path_constraint_position_timeline)>();

  int spine_path_constraint_position_timeline_get_frame_entries(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_get_frame_entries');
  late final _spine_path_constraint_position_timeline_get_frame_entries =
      _spine_path_constraint_position_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_path_constraint_position_timeline)>();

  int spine_path_constraint_position_timeline_get_frame_count(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_get_frame_count');
  late final _spine_path_constraint_position_timeline_get_frame_count =
      _spine_path_constraint_position_timeline_get_frame_countPtr
          .asFunction<int Function(spine_path_constraint_position_timeline)>();

  spine_array_float spine_path_constraint_position_timeline_get_frames(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_frames(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_get_frames');
  late final _spine_path_constraint_position_timeline_get_frames =
      _spine_path_constraint_position_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_path_constraint_position_timeline)>();

  double spine_path_constraint_position_timeline_get_duration(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_duration(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_get_duration');
  late final _spine_path_constraint_position_timeline_get_duration =
      _spine_path_constraint_position_timeline_get_durationPtr
          .asFunction<double Function(spine_path_constraint_position_timeline)>();

  spine_array_property_id spine_path_constraint_position_timeline_get_property_ids(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_get_property_ids');
  late final _spine_path_constraint_position_timeline_get_property_ids =
      _spine_path_constraint_position_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_path_constraint_position_timeline)>();

  spine_rtti spine_path_constraint_position_timeline_rtti() {
    return _spine_path_constraint_position_timeline_rtti();
  }

  late final _spine_path_constraint_position_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_path_constraint_position_timeline_rtti');
  late final _spine_path_constraint_position_timeline_rtti =
      _spine_path_constraint_position_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_path_constraint_spacing_timeline spine_path_constraint_spacing_timeline_create(
    int frameCount,
    int bezierCount,
    int constraintIndex,
  ) {
    return _spine_path_constraint_spacing_timeline_create(
      frameCount,
      bezierCount,
      constraintIndex,
    );
  }

  late final _spine_path_constraint_spacing_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_spacing_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_path_constraint_spacing_timeline_create');
  late final _spine_path_constraint_spacing_timeline_create = _spine_path_constraint_spacing_timeline_createPtr
      .asFunction<spine_path_constraint_spacing_timeline Function(int, int, int)>();

  void spine_path_constraint_spacing_timeline_dispose(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_dispose(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_dispose');
  late final _spine_path_constraint_spacing_timeline_dispose = _spine_path_constraint_spacing_timeline_disposePtr
      .asFunction<void Function(spine_path_constraint_spacing_timeline)>();

  spine_rtti spine_path_constraint_spacing_timeline_get_rtti(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_rtti(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_get_rtti');
  late final _spine_path_constraint_spacing_timeline_get_rtti = _spine_path_constraint_spacing_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_path_constraint_spacing_timeline)>();

  void spine_path_constraint_spacing_timeline_apply(
    spine_path_constraint_spacing_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_path_constraint_spacing_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_path_constraint_spacing_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_constraint_spacing_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_path_constraint_spacing_timeline_apply');
  late final _spine_path_constraint_spacing_timeline_apply =
      _spine_path_constraint_spacing_timeline_applyPtr.asFunction<
          void Function(spine_path_constraint_spacing_timeline, spine_skeleton, double, double, spine_array_event,
              double, int, int, bool)>();

  int spine_path_constraint_spacing_timeline_get_constraint_index(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_get_constraint_index');
  late final _spine_path_constraint_spacing_timeline_get_constraint_index =
      _spine_path_constraint_spacing_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_path_constraint_spacing_timeline)>();

  void spine_path_constraint_spacing_timeline_set_constraint_index(
    spine_path_constraint_spacing_timeline self,
    int inValue,
  ) {
    return _spine_path_constraint_spacing_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_path_constraint_spacing_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_spacing_timeline, ffi.Int)>>(
          'spine_path_constraint_spacing_timeline_set_constraint_index');
  late final _spine_path_constraint_spacing_timeline_set_constraint_index =
      _spine_path_constraint_spacing_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_path_constraint_spacing_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_path_constraint_spacing_timeline_set_frame(
    spine_path_constraint_spacing_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_path_constraint_spacing_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_path_constraint_spacing_timeline_set_framePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_path_constraint_spacing_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
      'spine_path_constraint_spacing_timeline_set_frame');
  late final _spine_path_constraint_spacing_timeline_set_frame = _spine_path_constraint_spacing_timeline_set_framePtr
      .asFunction<void Function(spine_path_constraint_spacing_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_path_constraint_spacing_timeline_get_curve_value(
    spine_path_constraint_spacing_timeline self,
    double time,
  ) {
    return _spine_path_constraint_spacing_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_spacing_timeline, ffi.Float)>>(
          'spine_path_constraint_spacing_timeline_get_curve_value');
  late final _spine_path_constraint_spacing_timeline_get_curve_value =
      _spine_path_constraint_spacing_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_path_constraint_spacing_timeline, double)>();

  double spine_path_constraint_spacing_timeline_get_relative_value(
    spine_path_constraint_spacing_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_path_constraint_spacing_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_path_constraint_spacing_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_path_constraint_spacing_timeline_get_relative_value');
  late final _spine_path_constraint_spacing_timeline_get_relative_value =
      _spine_path_constraint_spacing_timeline_get_relative_valuePtr
          .asFunction<double Function(spine_path_constraint_spacing_timeline, double, double, int, double, double)>();

  double spine_path_constraint_spacing_timeline_get_absolute_value_1(
    spine_path_constraint_spacing_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_path_constraint_spacing_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_path_constraint_spacing_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_path_constraint_spacing_timeline_get_absolute_value_1');
  late final _spine_path_constraint_spacing_timeline_get_absolute_value_1 =
      _spine_path_constraint_spacing_timeline_get_absolute_value_1Ptr
          .asFunction<double Function(spine_path_constraint_spacing_timeline, double, double, int, double, double)>();

  double spine_path_constraint_spacing_timeline_get_absolute_value_2(
    spine_path_constraint_spacing_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_path_constraint_spacing_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_path_constraint_spacing_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_path_constraint_spacing_timeline_get_absolute_value_2');
  late final _spine_path_constraint_spacing_timeline_get_absolute_value_2 =
      _spine_path_constraint_spacing_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_path_constraint_spacing_timeline, double, double, int, double, double, double)>();

  double spine_path_constraint_spacing_timeline_get_scale_value(
    spine_path_constraint_spacing_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_path_constraint_spacing_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_path_constraint_spacing_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32,
              ffi.Float, ffi.Float)>>('spine_path_constraint_spacing_timeline_get_scale_value');
  late final _spine_path_constraint_spacing_timeline_get_scale_value =
      _spine_path_constraint_spacing_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_path_constraint_spacing_timeline, double, double, int, int, double, double)>();

  void spine_path_constraint_spacing_timeline_set_linear(
    spine_path_constraint_spacing_timeline self,
    int frame,
  ) {
    return _spine_path_constraint_spacing_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_path_constraint_spacing_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_spacing_timeline, ffi.Size)>>(
          'spine_path_constraint_spacing_timeline_set_linear');
  late final _spine_path_constraint_spacing_timeline_set_linear = _spine_path_constraint_spacing_timeline_set_linearPtr
      .asFunction<void Function(spine_path_constraint_spacing_timeline, int)>();

  void spine_path_constraint_spacing_timeline_set_stepped(
    spine_path_constraint_spacing_timeline self,
    int frame,
  ) {
    return _spine_path_constraint_spacing_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_path_constraint_spacing_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_spacing_timeline, ffi.Size)>>(
          'spine_path_constraint_spacing_timeline_set_stepped');
  late final _spine_path_constraint_spacing_timeline_set_stepped =
      _spine_path_constraint_spacing_timeline_set_steppedPtr
          .asFunction<void Function(spine_path_constraint_spacing_timeline, int)>();

  void spine_path_constraint_spacing_timeline_set_bezier(
    spine_path_constraint_spacing_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_path_constraint_spacing_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_path_constraint_spacing_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_constraint_spacing_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_path_constraint_spacing_timeline_set_bezier');
  late final _spine_path_constraint_spacing_timeline_set_bezier =
      _spine_path_constraint_spacing_timeline_set_bezierPtr.asFunction<
          void Function(spine_path_constraint_spacing_timeline, int, int, double, double, double, double, double,
              double, double, double, double)>();

  double spine_path_constraint_spacing_timeline_get_bezier_value(
    spine_path_constraint_spacing_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_path_constraint_spacing_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_path_constraint_spacing_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_path_constraint_spacing_timeline_get_bezier_value');
  late final _spine_path_constraint_spacing_timeline_get_bezier_value =
      _spine_path_constraint_spacing_timeline_get_bezier_valuePtr
          .asFunction<double Function(spine_path_constraint_spacing_timeline, double, int, int, int)>();

  spine_array_float spine_path_constraint_spacing_timeline_get_curves(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_curves(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_get_curves');
  late final _spine_path_constraint_spacing_timeline_get_curves = _spine_path_constraint_spacing_timeline_get_curvesPtr
      .asFunction<spine_array_float Function(spine_path_constraint_spacing_timeline)>();

  int spine_path_constraint_spacing_timeline_get_frame_entries(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_get_frame_entries');
  late final _spine_path_constraint_spacing_timeline_get_frame_entries =
      _spine_path_constraint_spacing_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_path_constraint_spacing_timeline)>();

  int spine_path_constraint_spacing_timeline_get_frame_count(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_get_frame_count');
  late final _spine_path_constraint_spacing_timeline_get_frame_count =
      _spine_path_constraint_spacing_timeline_get_frame_countPtr
          .asFunction<int Function(spine_path_constraint_spacing_timeline)>();

  spine_array_float spine_path_constraint_spacing_timeline_get_frames(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_frames(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_get_frames');
  late final _spine_path_constraint_spacing_timeline_get_frames = _spine_path_constraint_spacing_timeline_get_framesPtr
      .asFunction<spine_array_float Function(spine_path_constraint_spacing_timeline)>();

  double spine_path_constraint_spacing_timeline_get_duration(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_duration(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_get_duration');
  late final _spine_path_constraint_spacing_timeline_get_duration =
      _spine_path_constraint_spacing_timeline_get_durationPtr
          .asFunction<double Function(spine_path_constraint_spacing_timeline)>();

  spine_array_property_id spine_path_constraint_spacing_timeline_get_property_ids(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_get_property_ids');
  late final _spine_path_constraint_spacing_timeline_get_property_ids =
      _spine_path_constraint_spacing_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_path_constraint_spacing_timeline)>();

  spine_rtti spine_path_constraint_spacing_timeline_rtti() {
    return _spine_path_constraint_spacing_timeline_rtti();
  }

  late final _spine_path_constraint_spacing_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_path_constraint_spacing_timeline_rtti');
  late final _spine_path_constraint_spacing_timeline_rtti =
      _spine_path_constraint_spacing_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_physics_constraint spine_physics_constraint_create(
    spine_physics_constraint_data data,
    spine_skeleton skeleton,
  ) {
    return _spine_physics_constraint_create(
      data,
      skeleton,
    );
  }

  late final _spine_physics_constraint_createPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint Function(spine_physics_constraint_data, spine_skeleton)>>(
          'spine_physics_constraint_create');
  late final _spine_physics_constraint_create = _spine_physics_constraint_createPtr
      .asFunction<spine_physics_constraint Function(spine_physics_constraint_data, spine_skeleton)>();

  void spine_physics_constraint_dispose(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint)>>('spine_physics_constraint_dispose');
  late final _spine_physics_constraint_dispose =
      _spine_physics_constraint_disposePtr.asFunction<void Function(spine_physics_constraint)>();

  spine_rtti spine_physics_constraint_get_rtti(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_physics_constraint)>>('spine_physics_constraint_get_rtti');
  late final _spine_physics_constraint_get_rtti =
      _spine_physics_constraint_get_rttiPtr.asFunction<spine_rtti Function(spine_physics_constraint)>();

  void spine_physics_constraint_update(
    spine_physics_constraint self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_physics_constraint_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_physics_constraint_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, spine_skeleton, ffi.Int32)>>(
          'spine_physics_constraint_update');
  late final _spine_physics_constraint_update =
      _spine_physics_constraint_updatePtr.asFunction<void Function(spine_physics_constraint, spine_skeleton, int)>();

  void spine_physics_constraint_sort(
    spine_physics_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_physics_constraint_sort(
      self,
      skeleton,
    );
  }

  late final _spine_physics_constraint_sortPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, spine_skeleton)>>(
          'spine_physics_constraint_sort');
  late final _spine_physics_constraint_sort =
      _spine_physics_constraint_sortPtr.asFunction<void Function(spine_physics_constraint, spine_skeleton)>();

  bool spine_physics_constraint_is_source_active(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_is_source_active(
      self,
    );
  }

  late final _spine_physics_constraint_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint)>>(
          'spine_physics_constraint_is_source_active');
  late final _spine_physics_constraint_is_source_active =
      _spine_physics_constraint_is_source_activePtr.asFunction<bool Function(spine_physics_constraint)>();

  spine_physics_constraint spine_physics_constraint_copy(
    spine_physics_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_physics_constraint_copy(
      self,
      skeleton,
    );
  }

  late final _spine_physics_constraint_copyPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint Function(spine_physics_constraint, spine_skeleton)>>(
          'spine_physics_constraint_copy');
  late final _spine_physics_constraint_copy = _spine_physics_constraint_copyPtr
      .asFunction<spine_physics_constraint Function(spine_physics_constraint, spine_skeleton)>();

  void spine_physics_constraint_reset(
    spine_physics_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_physics_constraint_reset(
      self,
      skeleton,
    );
  }

  late final _spine_physics_constraint_resetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, spine_skeleton)>>(
          'spine_physics_constraint_reset');
  late final _spine_physics_constraint_reset =
      _spine_physics_constraint_resetPtr.asFunction<void Function(spine_physics_constraint, spine_skeleton)>();

  /// Translates the physics constraint so next update() forces are applied as if
  /// the bone moved an additional amount in world space.
  void spine_physics_constraint_translate(
    spine_physics_constraint self,
    double x,
    double y,
  ) {
    return _spine_physics_constraint_translate(
      self,
      x,
      y,
    );
  }

  late final _spine_physics_constraint_translatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_translate');
  late final _spine_physics_constraint_translate =
      _spine_physics_constraint_translatePtr.asFunction<void Function(spine_physics_constraint, double, double)>();

  /// Rotates the physics constraint so next update() forces are applied as if the
  /// bone rotated around the specified point in world space.
  void spine_physics_constraint_rotate(
    spine_physics_constraint self,
    double x,
    double y,
    double degrees,
  ) {
    return _spine_physics_constraint_rotate(
      self,
      x,
      y,
      degrees,
    );
  }

  late final _spine_physics_constraint_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_rotate');
  late final _spine_physics_constraint_rotate =
      _spine_physics_constraint_rotatePtr.asFunction<void Function(spine_physics_constraint, double, double, double)>();

  /// The bone constrained by this physics constraint.
  spine_bone_pose spine_physics_constraint_get_bone(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_get_bone(
      self,
    );
  }

  late final _spine_physics_constraint_get_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone_pose Function(spine_physics_constraint)>>(
          'spine_physics_constraint_get_bone');
  late final _spine_physics_constraint_get_bone =
      _spine_physics_constraint_get_bonePtr.asFunction<spine_bone_pose Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_bone(
    spine_physics_constraint self,
    spine_bone_pose bone,
  ) {
    return _spine_physics_constraint_set_bone(
      self,
      bone,
    );
  }

  late final _spine_physics_constraint_set_bonePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, spine_bone_pose)>>(
          'spine_physics_constraint_set_bone');
  late final _spine_physics_constraint_set_bone =
      _spine_physics_constraint_set_bonePtr.asFunction<void Function(spine_physics_constraint, spine_bone_pose)>();

  spine_physics_constraint_data spine_physics_constraint_get_data(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_get_data(
      self,
    );
  }

  late final _spine_physics_constraint_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_data Function(spine_physics_constraint)>>(
          'spine_physics_constraint_get_data');
  late final _spine_physics_constraint_get_data = _spine_physics_constraint_get_dataPtr
      .asFunction<spine_physics_constraint_data Function(spine_physics_constraint)>();

  spine_physics_constraint_pose spine_physics_constraint_get_pose(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_get_pose(
      self,
    );
  }

  late final _spine_physics_constraint_get_posePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_pose Function(spine_physics_constraint)>>(
          'spine_physics_constraint_get_pose');
  late final _spine_physics_constraint_get_pose = _spine_physics_constraint_get_posePtr
      .asFunction<spine_physics_constraint_pose Function(spine_physics_constraint)>();

  spine_physics_constraint_pose spine_physics_constraint_get_applied_pose(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_get_applied_pose(
      self,
    );
  }

  late final _spine_physics_constraint_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_pose Function(spine_physics_constraint)>>(
          'spine_physics_constraint_get_applied_pose');
  late final _spine_physics_constraint_get_applied_pose = _spine_physics_constraint_get_applied_posePtr
      .asFunction<spine_physics_constraint_pose Function(spine_physics_constraint)>();

  void spine_physics_constraint_reset_constrained(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_reset_constrained(
      self,
    );
  }

  late final _spine_physics_constraint_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint)>>(
          'spine_physics_constraint_reset_constrained');
  late final _spine_physics_constraint_reset_constrained =
      _spine_physics_constraint_reset_constrainedPtr.asFunction<void Function(spine_physics_constraint)>();

  void spine_physics_constraint_constrained(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_constrained(
      self,
    );
  }

  late final _spine_physics_constraint_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint)>>('spine_physics_constraint_constrained');
  late final _spine_physics_constraint_constrained =
      _spine_physics_constraint_constrainedPtr.asFunction<void Function(spine_physics_constraint)>();

  bool spine_physics_constraint_is_pose_equal_to_applied(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_physics_constraint_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint)>>(
          'spine_physics_constraint_is_pose_equal_to_applied');
  late final _spine_physics_constraint_is_pose_equal_to_applied =
      _spine_physics_constraint_is_pose_equal_to_appliedPtr.asFunction<bool Function(spine_physics_constraint)>();

  bool spine_physics_constraint_is_active(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_is_active(
      self,
    );
  }

  late final _spine_physics_constraint_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint)>>('spine_physics_constraint_is_active');
  late final _spine_physics_constraint_is_active =
      _spine_physics_constraint_is_activePtr.asFunction<bool Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_active(
    spine_physics_constraint self,
    bool active,
  ) {
    return _spine_physics_constraint_set_active(
      self,
      active,
    );
  }

  late final _spine_physics_constraint_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Bool)>>(
          'spine_physics_constraint_set_active');
  late final _spine_physics_constraint_set_active =
      _spine_physics_constraint_set_activePtr.asFunction<void Function(spine_physics_constraint, bool)>();

  spine_rtti spine_physics_constraint_rtti() {
    return _spine_physics_constraint_rtti();
  }

  late final _spine_physics_constraint_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_physics_constraint_rtti');
  late final _spine_physics_constraint_rtti = _spine_physics_constraint_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_physics_constraint_base_dispose(
    spine_physics_constraint_base self,
  ) {
    return _spine_physics_constraint_base_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_base_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_dispose');
  late final _spine_physics_constraint_base_dispose =
      _spine_physics_constraint_base_disposePtr.asFunction<void Function(spine_physics_constraint_base)>();

  spine_physics_constraint_data spine_physics_constraint_base_get_data(
    spine_physics_constraint_base self,
  ) {
    return _spine_physics_constraint_base_get_data(
      self,
    );
  }

  late final _spine_physics_constraint_base_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_data Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_get_data');
  late final _spine_physics_constraint_base_get_data = _spine_physics_constraint_base_get_dataPtr
      .asFunction<spine_physics_constraint_data Function(spine_physics_constraint_base)>();

  spine_physics_constraint_pose spine_physics_constraint_base_get_pose(
    spine_physics_constraint_base self,
  ) {
    return _spine_physics_constraint_base_get_pose(
      self,
    );
  }

  late final _spine_physics_constraint_base_get_posePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_pose Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_get_pose');
  late final _spine_physics_constraint_base_get_pose = _spine_physics_constraint_base_get_posePtr
      .asFunction<spine_physics_constraint_pose Function(spine_physics_constraint_base)>();

  spine_physics_constraint_pose spine_physics_constraint_base_get_applied_pose(
    spine_physics_constraint_base self,
  ) {
    return _spine_physics_constraint_base_get_applied_pose(
      self,
    );
  }

  late final _spine_physics_constraint_base_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_pose Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_get_applied_pose');
  late final _spine_physics_constraint_base_get_applied_pose = _spine_physics_constraint_base_get_applied_posePtr
      .asFunction<spine_physics_constraint_pose Function(spine_physics_constraint_base)>();

  void spine_physics_constraint_base_reset_constrained(
    spine_physics_constraint_base self,
  ) {
    return _spine_physics_constraint_base_reset_constrained(
      self,
    );
  }

  late final _spine_physics_constraint_base_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_reset_constrained');
  late final _spine_physics_constraint_base_reset_constrained =
      _spine_physics_constraint_base_reset_constrainedPtr.asFunction<void Function(spine_physics_constraint_base)>();

  void spine_physics_constraint_base_constrained(
    spine_physics_constraint_base self,
  ) {
    return _spine_physics_constraint_base_constrained(
      self,
    );
  }

  late final _spine_physics_constraint_base_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_constrained');
  late final _spine_physics_constraint_base_constrained =
      _spine_physics_constraint_base_constrainedPtr.asFunction<void Function(spine_physics_constraint_base)>();

  bool spine_physics_constraint_base_is_pose_equal_to_applied(
    spine_physics_constraint_base self,
  ) {
    return _spine_physics_constraint_base_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_physics_constraint_base_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_is_pose_equal_to_applied');
  late final _spine_physics_constraint_base_is_pose_equal_to_applied =
      _spine_physics_constraint_base_is_pose_equal_to_appliedPtr
          .asFunction<bool Function(spine_physics_constraint_base)>();

  bool spine_physics_constraint_base_is_active(
    spine_physics_constraint_base self,
  ) {
    return _spine_physics_constraint_base_is_active(
      self,
    );
  }

  late final _spine_physics_constraint_base_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_is_active');
  late final _spine_physics_constraint_base_is_active =
      _spine_physics_constraint_base_is_activePtr.asFunction<bool Function(spine_physics_constraint_base)>();

  void spine_physics_constraint_base_set_active(
    spine_physics_constraint_base self,
    bool active,
  ) {
    return _spine_physics_constraint_base_set_active(
      self,
      active,
    );
  }

  late final _spine_physics_constraint_base_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_base, ffi.Bool)>>(
          'spine_physics_constraint_base_set_active');
  late final _spine_physics_constraint_base_set_active =
      _spine_physics_constraint_base_set_activePtr.asFunction<void Function(spine_physics_constraint_base, bool)>();

  spine_rtti spine_physics_constraint_base_get_rtti(
    spine_physics_constraint_base self,
  ) {
    return _spine_physics_constraint_base_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_base_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_get_rtti');
  late final _spine_physics_constraint_base_get_rtti =
      _spine_physics_constraint_base_get_rttiPtr.asFunction<spine_rtti Function(spine_physics_constraint_base)>();

  void spine_physics_constraint_base_sort(
    spine_physics_constraint_base self,
    spine_skeleton skeleton,
  ) {
    return _spine_physics_constraint_base_sort(
      self,
      skeleton,
    );
  }

  late final _spine_physics_constraint_base_sortPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_base, spine_skeleton)>>(
          'spine_physics_constraint_base_sort');
  late final _spine_physics_constraint_base_sort =
      _spine_physics_constraint_base_sortPtr.asFunction<void Function(spine_physics_constraint_base, spine_skeleton)>();

  bool spine_physics_constraint_base_is_source_active(
    spine_physics_constraint_base self,
  ) {
    return _spine_physics_constraint_base_is_source_active(
      self,
    );
  }

  late final _spine_physics_constraint_base_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_base)>>(
          'spine_physics_constraint_base_is_source_active');
  late final _spine_physics_constraint_base_is_source_active =
      _spine_physics_constraint_base_is_source_activePtr.asFunction<bool Function(spine_physics_constraint_base)>();

  /// Inherited from Update
  void spine_physics_constraint_base_update(
    spine_physics_constraint_base self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_physics_constraint_base_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_physics_constraint_base_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_base, spine_skeleton, ffi.Int32)>>(
          'spine_physics_constraint_base_update');
  late final _spine_physics_constraint_base_update = _spine_physics_constraint_base_updatePtr
      .asFunction<void Function(spine_physics_constraint_base, spine_skeleton, int)>();

  spine_rtti spine_physics_constraint_base_rtti() {
    return _spine_physics_constraint_base_rtti();
  }

  late final _spine_physics_constraint_base_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_physics_constraint_base_rtti');
  late final _spine_physics_constraint_base_rtti =
      _spine_physics_constraint_base_rttiPtr.asFunction<spine_rtti Function()>();

  spine_physics_constraint_damping_timeline spine_physics_constraint_damping_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_damping_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_damping_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_damping_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_physics_constraint_damping_timeline_create');
  late final _spine_physics_constraint_damping_timeline_create = _spine_physics_constraint_damping_timeline_createPtr
      .asFunction<spine_physics_constraint_damping_timeline Function(int, int, int)>();

  void spine_physics_constraint_damping_timeline_dispose(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_dispose');
  late final _spine_physics_constraint_damping_timeline_dispose = _spine_physics_constraint_damping_timeline_disposePtr
      .asFunction<void Function(spine_physics_constraint_damping_timeline)>();

  spine_rtti spine_physics_constraint_damping_timeline_get_rtti(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_get_rtti');
  late final _spine_physics_constraint_damping_timeline_get_rtti =
      _spine_physics_constraint_damping_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_physics_constraint_damping_timeline)>();

  void spine_physics_constraint_damping_timeline_apply(
    spine_physics_constraint_damping_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_damping_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_damping_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_damping_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_damping_timeline_apply');
  late final _spine_physics_constraint_damping_timeline_apply =
      _spine_physics_constraint_damping_timeline_applyPtr.asFunction<
          void Function(spine_physics_constraint_damping_timeline, spine_skeleton, double, double, spine_array_event,
              double, int, int, bool)>();

  int spine_physics_constraint_damping_timeline_get_constraint_index(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_get_constraint_index');
  late final _spine_physics_constraint_damping_timeline_get_constraint_index =
      _spine_physics_constraint_damping_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_damping_timeline)>();

  void spine_physics_constraint_damping_timeline_set_constraint_index(
    spine_physics_constraint_damping_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_damping_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_damping_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_damping_timeline, ffi.Int)>>(
          'spine_physics_constraint_damping_timeline_set_constraint_index');
  late final _spine_physics_constraint_damping_timeline_set_constraint_index =
      _spine_physics_constraint_damping_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_physics_constraint_damping_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_physics_constraint_damping_timeline_set_frame(
    spine_physics_constraint_damping_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_damping_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_damping_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_damping_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_damping_timeline_set_frame');
  late final _spine_physics_constraint_damping_timeline_set_frame =
      _spine_physics_constraint_damping_timeline_set_framePtr
          .asFunction<void Function(spine_physics_constraint_damping_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_physics_constraint_damping_timeline_get_curve_value(
    spine_physics_constraint_damping_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_damping_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_damping_timeline, ffi.Float)>>(
          'spine_physics_constraint_damping_timeline_get_curve_value');
  late final _spine_physics_constraint_damping_timeline_get_curve_value =
      _spine_physics_constraint_damping_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_physics_constraint_damping_timeline, double)>();

  double spine_physics_constraint_damping_timeline_get_relative_value(
    spine_physics_constraint_damping_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_damping_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_damping_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_damping_timeline_get_relative_value');
  late final _spine_physics_constraint_damping_timeline_get_relative_value =
      _spine_physics_constraint_damping_timeline_get_relative_valuePtr.asFunction<
          double Function(spine_physics_constraint_damping_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_damping_timeline_get_absolute_value_1(
    spine_physics_constraint_damping_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_damping_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_damping_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_damping_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_damping_timeline_get_absolute_value_1 =
      _spine_physics_constraint_damping_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(spine_physics_constraint_damping_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_damping_timeline_get_absolute_value_2(
    spine_physics_constraint_damping_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_damping_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_damping_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_damping_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_damping_timeline_get_absolute_value_2 =
      _spine_physics_constraint_damping_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_physics_constraint_damping_timeline, double, double, int, double, double, double)>();

  double spine_physics_constraint_damping_timeline_get_scale_value(
    spine_physics_constraint_damping_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_damping_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_damping_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_damping_timeline_get_scale_value');
  late final _spine_physics_constraint_damping_timeline_get_scale_value =
      _spine_physics_constraint_damping_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_damping_timeline, double, double, int, int, double, double)>();

  void spine_physics_constraint_damping_timeline_set_linear(
    spine_physics_constraint_damping_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_damping_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_damping_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_damping_timeline, ffi.Size)>>(
          'spine_physics_constraint_damping_timeline_set_linear');
  late final _spine_physics_constraint_damping_timeline_set_linear =
      _spine_physics_constraint_damping_timeline_set_linearPtr
          .asFunction<void Function(spine_physics_constraint_damping_timeline, int)>();

  void spine_physics_constraint_damping_timeline_set_stepped(
    spine_physics_constraint_damping_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_damping_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_damping_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_damping_timeline, ffi.Size)>>(
          'spine_physics_constraint_damping_timeline_set_stepped');
  late final _spine_physics_constraint_damping_timeline_set_stepped =
      _spine_physics_constraint_damping_timeline_set_steppedPtr
          .asFunction<void Function(spine_physics_constraint_damping_timeline, int)>();

  void spine_physics_constraint_damping_timeline_set_bezier(
    spine_physics_constraint_damping_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_damping_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_damping_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_damping_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_damping_timeline_set_bezier');
  late final _spine_physics_constraint_damping_timeline_set_bezier =
      _spine_physics_constraint_damping_timeline_set_bezierPtr.asFunction<
          void Function(spine_physics_constraint_damping_timeline, int, int, double, double, double, double, double,
              double, double, double, double)>();

  double spine_physics_constraint_damping_timeline_get_bezier_value(
    spine_physics_constraint_damping_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_damping_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_damping_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_physics_constraint_damping_timeline_get_bezier_value');
  late final _spine_physics_constraint_damping_timeline_get_bezier_value =
      _spine_physics_constraint_damping_timeline_get_bezier_valuePtr
          .asFunction<double Function(spine_physics_constraint_damping_timeline, double, int, int, int)>();

  spine_array_float spine_physics_constraint_damping_timeline_get_curves(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_get_curves');
  late final _spine_physics_constraint_damping_timeline_get_curves =
      _spine_physics_constraint_damping_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_physics_constraint_damping_timeline)>();

  int spine_physics_constraint_damping_timeline_get_frame_entries(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_get_frame_entries');
  late final _spine_physics_constraint_damping_timeline_get_frame_entries =
      _spine_physics_constraint_damping_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_damping_timeline)>();

  int spine_physics_constraint_damping_timeline_get_frame_count(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_get_frame_count');
  late final _spine_physics_constraint_damping_timeline_get_frame_count =
      _spine_physics_constraint_damping_timeline_get_frame_countPtr
          .asFunction<int Function(spine_physics_constraint_damping_timeline)>();

  spine_array_float spine_physics_constraint_damping_timeline_get_frames(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_get_frames');
  late final _spine_physics_constraint_damping_timeline_get_frames =
      _spine_physics_constraint_damping_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_physics_constraint_damping_timeline)>();

  double spine_physics_constraint_damping_timeline_get_duration(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_get_duration');
  late final _spine_physics_constraint_damping_timeline_get_duration =
      _spine_physics_constraint_damping_timeline_get_durationPtr
          .asFunction<double Function(spine_physics_constraint_damping_timeline)>();

  spine_array_property_id spine_physics_constraint_damping_timeline_get_property_ids(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_get_property_ids');
  late final _spine_physics_constraint_damping_timeline_get_property_ids =
      _spine_physics_constraint_damping_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_physics_constraint_damping_timeline)>();

  spine_rtti spine_physics_constraint_damping_timeline_rtti() {
    return _spine_physics_constraint_damping_timeline_rtti();
  }

  late final _spine_physics_constraint_damping_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_physics_constraint_damping_timeline_rtti');
  late final _spine_physics_constraint_damping_timeline_rtti =
      _spine_physics_constraint_damping_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_physics_constraint_data spine_physics_constraint_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_physics_constraint_data_create(
      name,
    );
  }

  late final _spine_physics_constraint_data_createPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_data Function(ffi.Pointer<ffi.Char>)>>(
          'spine_physics_constraint_data_create');
  late final _spine_physics_constraint_data_create = _spine_physics_constraint_data_createPtr
      .asFunction<spine_physics_constraint_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_physics_constraint_data_dispose(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_dispose');
  late final _spine_physics_constraint_data_dispose =
      _spine_physics_constraint_data_disposePtr.asFunction<void Function(spine_physics_constraint_data)>();

  spine_rtti spine_physics_constraint_data_get_rtti(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_rtti');
  late final _spine_physics_constraint_data_get_rtti =
      _spine_physics_constraint_data_get_rttiPtr.asFunction<spine_rtti Function(spine_physics_constraint_data)>();

  spine_constraint spine_physics_constraint_data_create_method(
    spine_physics_constraint_data self,
    spine_skeleton skeleton,
  ) {
    return _spine_physics_constraint_data_create_method(
      self,
      skeleton,
    );
  }

  late final _spine_physics_constraint_data_create_methodPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_physics_constraint_data, spine_skeleton)>>(
          'spine_physics_constraint_data_create_method');
  late final _spine_physics_constraint_data_create_method = _spine_physics_constraint_data_create_methodPtr
      .asFunction<spine_constraint Function(spine_physics_constraint_data, spine_skeleton)>();

  /// The bone constrained by this physics constraint.
  spine_bone_data spine_physics_constraint_data_get_bone(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_bone(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_bone');
  late final _spine_physics_constraint_data_get_bone =
      _spine_physics_constraint_data_get_bonePtr.asFunction<spine_bone_data Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_bone(
    spine_physics_constraint_data self,
    spine_bone_data bone,
  ) {
    return _spine_physics_constraint_data_set_bone(
      self,
      bone,
    );
  }

  late final _spine_physics_constraint_data_set_bonePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_bone_data)>>(
          'spine_physics_constraint_data_set_bone');
  late final _spine_physics_constraint_data_set_bone = _spine_physics_constraint_data_set_bonePtr
      .asFunction<void Function(spine_physics_constraint_data, spine_bone_data)>();

  double spine_physics_constraint_data_get_step(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_step(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_stepPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_step');
  late final _spine_physics_constraint_data_get_step =
      _spine_physics_constraint_data_get_stepPtr.asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_step(
    spine_physics_constraint_data self,
    double step,
  ) {
    return _spine_physics_constraint_data_set_step(
      self,
      step,
    );
  }

  late final _spine_physics_constraint_data_set_stepPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
          'spine_physics_constraint_data_set_step');
  late final _spine_physics_constraint_data_set_step =
      _spine_physics_constraint_data_set_stepPtr.asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_x(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_x(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_x');
  late final _spine_physics_constraint_data_get_x =
      _spine_physics_constraint_data_get_xPtr.asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_x(
    spine_physics_constraint_data self,
    double x,
  ) {
    return _spine_physics_constraint_data_set_x(
      self,
      x,
    );
  }

  late final _spine_physics_constraint_data_set_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
          'spine_physics_constraint_data_set_x');
  late final _spine_physics_constraint_data_set_x =
      _spine_physics_constraint_data_set_xPtr.asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_y(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_y(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_y');
  late final _spine_physics_constraint_data_get_y =
      _spine_physics_constraint_data_get_yPtr.asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_y(
    spine_physics_constraint_data self,
    double y,
  ) {
    return _spine_physics_constraint_data_set_y(
      self,
      y,
    );
  }

  late final _spine_physics_constraint_data_set_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
          'spine_physics_constraint_data_set_y');
  late final _spine_physics_constraint_data_set_y =
      _spine_physics_constraint_data_set_yPtr.asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_rotate(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_rotate(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_rotate');
  late final _spine_physics_constraint_data_get_rotate =
      _spine_physics_constraint_data_get_rotatePtr.asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_rotate(
    spine_physics_constraint_data self,
    double rotate,
  ) {
    return _spine_physics_constraint_data_set_rotate(
      self,
      rotate,
    );
  }

  late final _spine_physics_constraint_data_set_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
          'spine_physics_constraint_data_set_rotate');
  late final _spine_physics_constraint_data_set_rotate =
      _spine_physics_constraint_data_set_rotatePtr.asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_scale_x(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_scale_x(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_scale_x');
  late final _spine_physics_constraint_data_get_scale_x =
      _spine_physics_constraint_data_get_scale_xPtr.asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_scale_x(
    spine_physics_constraint_data self,
    double scaleX,
  ) {
    return _spine_physics_constraint_data_set_scale_x(
      self,
      scaleX,
    );
  }

  late final _spine_physics_constraint_data_set_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
          'spine_physics_constraint_data_set_scale_x');
  late final _spine_physics_constraint_data_set_scale_x =
      _spine_physics_constraint_data_set_scale_xPtr.asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_shear_x(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_shear_x(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_shear_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_shear_x');
  late final _spine_physics_constraint_data_get_shear_x =
      _spine_physics_constraint_data_get_shear_xPtr.asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_shear_x(
    spine_physics_constraint_data self,
    double shearX,
  ) {
    return _spine_physics_constraint_data_set_shear_x(
      self,
      shearX,
    );
  }

  late final _spine_physics_constraint_data_set_shear_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
          'spine_physics_constraint_data_set_shear_x');
  late final _spine_physics_constraint_data_set_shear_x =
      _spine_physics_constraint_data_set_shear_xPtr.asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_limit(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_limit(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_limitPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_limit');
  late final _spine_physics_constraint_data_get_limit =
      _spine_physics_constraint_data_get_limitPtr.asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_limit(
    spine_physics_constraint_data self,
    double limit,
  ) {
    return _spine_physics_constraint_data_set_limit(
      self,
      limit,
    );
  }

  late final _spine_physics_constraint_data_set_limitPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
          'spine_physics_constraint_data_set_limit');
  late final _spine_physics_constraint_data_set_limit =
      _spine_physics_constraint_data_set_limitPtr.asFunction<void Function(spine_physics_constraint_data, double)>();

  bool spine_physics_constraint_data_get_inertia_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_inertia_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_inertia_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_inertia_global');
  late final _spine_physics_constraint_data_get_inertia_global =
      _spine_physics_constraint_data_get_inertia_globalPtr.asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_inertia_global(
    spine_physics_constraint_data self,
    bool inertiaGlobal,
  ) {
    return _spine_physics_constraint_data_set_inertia_global(
      self,
      inertiaGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_inertia_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Bool)>>(
          'spine_physics_constraint_data_set_inertia_global');
  late final _spine_physics_constraint_data_set_inertia_global = _spine_physics_constraint_data_set_inertia_globalPtr
      .asFunction<void Function(spine_physics_constraint_data, bool)>();

  bool spine_physics_constraint_data_get_strength_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_strength_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_strength_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_strength_global');
  late final _spine_physics_constraint_data_get_strength_global =
      _spine_physics_constraint_data_get_strength_globalPtr.asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_strength_global(
    spine_physics_constraint_data self,
    bool strengthGlobal,
  ) {
    return _spine_physics_constraint_data_set_strength_global(
      self,
      strengthGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_strength_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Bool)>>(
          'spine_physics_constraint_data_set_strength_global');
  late final _spine_physics_constraint_data_set_strength_global = _spine_physics_constraint_data_set_strength_globalPtr
      .asFunction<void Function(spine_physics_constraint_data, bool)>();

  bool spine_physics_constraint_data_get_damping_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_damping_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_damping_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_damping_global');
  late final _spine_physics_constraint_data_get_damping_global =
      _spine_physics_constraint_data_get_damping_globalPtr.asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_damping_global(
    spine_physics_constraint_data self,
    bool dampingGlobal,
  ) {
    return _spine_physics_constraint_data_set_damping_global(
      self,
      dampingGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_damping_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Bool)>>(
          'spine_physics_constraint_data_set_damping_global');
  late final _spine_physics_constraint_data_set_damping_global = _spine_physics_constraint_data_set_damping_globalPtr
      .asFunction<void Function(spine_physics_constraint_data, bool)>();

  bool spine_physics_constraint_data_get_mass_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_mass_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_mass_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_mass_global');
  late final _spine_physics_constraint_data_get_mass_global =
      _spine_physics_constraint_data_get_mass_globalPtr.asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_mass_global(
    spine_physics_constraint_data self,
    bool massGlobal,
  ) {
    return _spine_physics_constraint_data_set_mass_global(
      self,
      massGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_mass_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Bool)>>(
          'spine_physics_constraint_data_set_mass_global');
  late final _spine_physics_constraint_data_set_mass_global = _spine_physics_constraint_data_set_mass_globalPtr
      .asFunction<void Function(spine_physics_constraint_data, bool)>();

  bool spine_physics_constraint_data_get_wind_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_wind_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_wind_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_wind_global');
  late final _spine_physics_constraint_data_get_wind_global =
      _spine_physics_constraint_data_get_wind_globalPtr.asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_wind_global(
    spine_physics_constraint_data self,
    bool windGlobal,
  ) {
    return _spine_physics_constraint_data_set_wind_global(
      self,
      windGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_wind_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Bool)>>(
          'spine_physics_constraint_data_set_wind_global');
  late final _spine_physics_constraint_data_set_wind_global = _spine_physics_constraint_data_set_wind_globalPtr
      .asFunction<void Function(spine_physics_constraint_data, bool)>();

  bool spine_physics_constraint_data_get_gravity_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_gravity_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_gravity_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_gravity_global');
  late final _spine_physics_constraint_data_get_gravity_global =
      _spine_physics_constraint_data_get_gravity_globalPtr.asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_gravity_global(
    spine_physics_constraint_data self,
    bool gravityGlobal,
  ) {
    return _spine_physics_constraint_data_set_gravity_global(
      self,
      gravityGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_gravity_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Bool)>>(
          'spine_physics_constraint_data_set_gravity_global');
  late final _spine_physics_constraint_data_set_gravity_global = _spine_physics_constraint_data_set_gravity_globalPtr
      .asFunction<void Function(spine_physics_constraint_data, bool)>();

  bool spine_physics_constraint_data_get_mix_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_mix_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_mix_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_mix_global');
  late final _spine_physics_constraint_data_get_mix_global =
      _spine_physics_constraint_data_get_mix_globalPtr.asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_mix_global(
    spine_physics_constraint_data self,
    bool mixGlobal,
  ) {
    return _spine_physics_constraint_data_set_mix_global(
      self,
      mixGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_mix_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Bool)>>(
          'spine_physics_constraint_data_set_mix_global');
  late final _spine_physics_constraint_data_set_mix_global =
      _spine_physics_constraint_data_set_mix_globalPtr.asFunction<void Function(spine_physics_constraint_data, bool)>();

  /// Resolve ambiguity by forwarding to PosedData's implementation
  ffi.Pointer<ffi.Char> spine_physics_constraint_data_get_name(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_name(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_name');
  late final _spine_physics_constraint_data_get_name = _spine_physics_constraint_data_get_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_physics_constraint_data)>();

  bool spine_physics_constraint_data_get_skin_required(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_skin_required(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_skin_required');
  late final _spine_physics_constraint_data_get_skin_required =
      _spine_physics_constraint_data_get_skin_requiredPtr.asFunction<bool Function(spine_physics_constraint_data)>();

  spine_physics_constraint_pose spine_physics_constraint_data_get_setup_pose(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_setup_pose(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_setup_posePtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_pose Function(spine_physics_constraint_data)>>(
          'spine_physics_constraint_data_get_setup_pose');
  late final _spine_physics_constraint_data_get_setup_pose = _spine_physics_constraint_data_get_setup_posePtr
      .asFunction<spine_physics_constraint_pose Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_skin_required(
    spine_physics_constraint_data self,
    bool skinRequired,
  ) {
    return _spine_physics_constraint_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_physics_constraint_data_set_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Bool)>>(
          'spine_physics_constraint_data_set_skin_required');
  late final _spine_physics_constraint_data_set_skin_required = _spine_physics_constraint_data_set_skin_requiredPtr
      .asFunction<void Function(spine_physics_constraint_data, bool)>();

  spine_rtti spine_physics_constraint_data_rtti() {
    return _spine_physics_constraint_data_rtti();
  }

  late final _spine_physics_constraint_data_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_physics_constraint_data_rtti');
  late final _spine_physics_constraint_data_rtti =
      _spine_physics_constraint_data_rttiPtr.asFunction<spine_rtti Function()>();

  spine_physics_constraint_gravity_timeline spine_physics_constraint_gravity_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_gravity_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_gravity_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_physics_constraint_gravity_timeline_create');
  late final _spine_physics_constraint_gravity_timeline_create = _spine_physics_constraint_gravity_timeline_createPtr
      .asFunction<spine_physics_constraint_gravity_timeline Function(int, int, int)>();

  void spine_physics_constraint_gravity_timeline_dispose(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_dispose');
  late final _spine_physics_constraint_gravity_timeline_dispose = _spine_physics_constraint_gravity_timeline_disposePtr
      .asFunction<void Function(spine_physics_constraint_gravity_timeline)>();

  spine_rtti spine_physics_constraint_gravity_timeline_get_rtti(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_get_rtti');
  late final _spine_physics_constraint_gravity_timeline_get_rtti =
      _spine_physics_constraint_gravity_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_physics_constraint_gravity_timeline)>();

  void spine_physics_constraint_gravity_timeline_apply(
    spine_physics_constraint_gravity_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_gravity_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_gravity_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_gravity_timeline_apply');
  late final _spine_physics_constraint_gravity_timeline_apply =
      _spine_physics_constraint_gravity_timeline_applyPtr.asFunction<
          void Function(spine_physics_constraint_gravity_timeline, spine_skeleton, double, double, spine_array_event,
              double, int, int, bool)>();

  int spine_physics_constraint_gravity_timeline_get_constraint_index(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_get_constraint_index');
  late final _spine_physics_constraint_gravity_timeline_get_constraint_index =
      _spine_physics_constraint_gravity_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_gravity_timeline)>();

  void spine_physics_constraint_gravity_timeline_set_constraint_index(
    spine_physics_constraint_gravity_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_gravity_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_gravity_timeline, ffi.Int)>>(
          'spine_physics_constraint_gravity_timeline_set_constraint_index');
  late final _spine_physics_constraint_gravity_timeline_set_constraint_index =
      _spine_physics_constraint_gravity_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_physics_constraint_gravity_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_physics_constraint_gravity_timeline_set_frame(
    spine_physics_constraint_gravity_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_gravity_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_gravity_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_gravity_timeline_set_frame');
  late final _spine_physics_constraint_gravity_timeline_set_frame =
      _spine_physics_constraint_gravity_timeline_set_framePtr
          .asFunction<void Function(spine_physics_constraint_gravity_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_physics_constraint_gravity_timeline_get_curve_value(
    spine_physics_constraint_gravity_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_gravity_timeline, ffi.Float)>>(
          'spine_physics_constraint_gravity_timeline_get_curve_value');
  late final _spine_physics_constraint_gravity_timeline_get_curve_value =
      _spine_physics_constraint_gravity_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_physics_constraint_gravity_timeline, double)>();

  double spine_physics_constraint_gravity_timeline_get_relative_value(
    spine_physics_constraint_gravity_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_gravity_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_gravity_timeline_get_relative_value');
  late final _spine_physics_constraint_gravity_timeline_get_relative_value =
      _spine_physics_constraint_gravity_timeline_get_relative_valuePtr.asFunction<
          double Function(spine_physics_constraint_gravity_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_gravity_timeline_get_absolute_value_1(
    spine_physics_constraint_gravity_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_gravity_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_gravity_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_gravity_timeline_get_absolute_value_1 =
      _spine_physics_constraint_gravity_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(spine_physics_constraint_gravity_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_gravity_timeline_get_absolute_value_2(
    spine_physics_constraint_gravity_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_gravity_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_gravity_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_gravity_timeline_get_absolute_value_2 =
      _spine_physics_constraint_gravity_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_physics_constraint_gravity_timeline, double, double, int, double, double, double)>();

  double spine_physics_constraint_gravity_timeline_get_scale_value(
    spine_physics_constraint_gravity_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_gravity_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_gravity_timeline_get_scale_value');
  late final _spine_physics_constraint_gravity_timeline_get_scale_value =
      _spine_physics_constraint_gravity_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_gravity_timeline, double, double, int, int, double, double)>();

  void spine_physics_constraint_gravity_timeline_set_linear(
    spine_physics_constraint_gravity_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_gravity_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_gravity_timeline, ffi.Size)>>(
          'spine_physics_constraint_gravity_timeline_set_linear');
  late final _spine_physics_constraint_gravity_timeline_set_linear =
      _spine_physics_constraint_gravity_timeline_set_linearPtr
          .asFunction<void Function(spine_physics_constraint_gravity_timeline, int)>();

  void spine_physics_constraint_gravity_timeline_set_stepped(
    spine_physics_constraint_gravity_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_gravity_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_gravity_timeline, ffi.Size)>>(
          'spine_physics_constraint_gravity_timeline_set_stepped');
  late final _spine_physics_constraint_gravity_timeline_set_stepped =
      _spine_physics_constraint_gravity_timeline_set_steppedPtr
          .asFunction<void Function(spine_physics_constraint_gravity_timeline, int)>();

  void spine_physics_constraint_gravity_timeline_set_bezier(
    spine_physics_constraint_gravity_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_gravity_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_gravity_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_gravity_timeline_set_bezier');
  late final _spine_physics_constraint_gravity_timeline_set_bezier =
      _spine_physics_constraint_gravity_timeline_set_bezierPtr.asFunction<
          void Function(spine_physics_constraint_gravity_timeline, int, int, double, double, double, double, double,
              double, double, double, double)>();

  double spine_physics_constraint_gravity_timeline_get_bezier_value(
    spine_physics_constraint_gravity_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_gravity_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_physics_constraint_gravity_timeline_get_bezier_value');
  late final _spine_physics_constraint_gravity_timeline_get_bezier_value =
      _spine_physics_constraint_gravity_timeline_get_bezier_valuePtr
          .asFunction<double Function(spine_physics_constraint_gravity_timeline, double, int, int, int)>();

  spine_array_float spine_physics_constraint_gravity_timeline_get_curves(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_get_curves');
  late final _spine_physics_constraint_gravity_timeline_get_curves =
      _spine_physics_constraint_gravity_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_physics_constraint_gravity_timeline)>();

  int spine_physics_constraint_gravity_timeline_get_frame_entries(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_get_frame_entries');
  late final _spine_physics_constraint_gravity_timeline_get_frame_entries =
      _spine_physics_constraint_gravity_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_gravity_timeline)>();

  int spine_physics_constraint_gravity_timeline_get_frame_count(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_get_frame_count');
  late final _spine_physics_constraint_gravity_timeline_get_frame_count =
      _spine_physics_constraint_gravity_timeline_get_frame_countPtr
          .asFunction<int Function(spine_physics_constraint_gravity_timeline)>();

  spine_array_float spine_physics_constraint_gravity_timeline_get_frames(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_get_frames');
  late final _spine_physics_constraint_gravity_timeline_get_frames =
      _spine_physics_constraint_gravity_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_physics_constraint_gravity_timeline)>();

  double spine_physics_constraint_gravity_timeline_get_duration(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_get_duration');
  late final _spine_physics_constraint_gravity_timeline_get_duration =
      _spine_physics_constraint_gravity_timeline_get_durationPtr
          .asFunction<double Function(spine_physics_constraint_gravity_timeline)>();

  spine_array_property_id spine_physics_constraint_gravity_timeline_get_property_ids(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_get_property_ids');
  late final _spine_physics_constraint_gravity_timeline_get_property_ids =
      _spine_physics_constraint_gravity_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_physics_constraint_gravity_timeline)>();

  spine_rtti spine_physics_constraint_gravity_timeline_rtti() {
    return _spine_physics_constraint_gravity_timeline_rtti();
  }

  late final _spine_physics_constraint_gravity_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_physics_constraint_gravity_timeline_rtti');
  late final _spine_physics_constraint_gravity_timeline_rtti =
      _spine_physics_constraint_gravity_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_physics_constraint_inertia_timeline spine_physics_constraint_inertia_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_inertia_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_inertia_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_physics_constraint_inertia_timeline_create');
  late final _spine_physics_constraint_inertia_timeline_create = _spine_physics_constraint_inertia_timeline_createPtr
      .asFunction<spine_physics_constraint_inertia_timeline Function(int, int, int)>();

  void spine_physics_constraint_inertia_timeline_dispose(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_dispose');
  late final _spine_physics_constraint_inertia_timeline_dispose = _spine_physics_constraint_inertia_timeline_disposePtr
      .asFunction<void Function(spine_physics_constraint_inertia_timeline)>();

  spine_rtti spine_physics_constraint_inertia_timeline_get_rtti(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_get_rtti');
  late final _spine_physics_constraint_inertia_timeline_get_rtti =
      _spine_physics_constraint_inertia_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_physics_constraint_inertia_timeline)>();

  void spine_physics_constraint_inertia_timeline_apply(
    spine_physics_constraint_inertia_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_inertia_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_inertia_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_inertia_timeline_apply');
  late final _spine_physics_constraint_inertia_timeline_apply =
      _spine_physics_constraint_inertia_timeline_applyPtr.asFunction<
          void Function(spine_physics_constraint_inertia_timeline, spine_skeleton, double, double, spine_array_event,
              double, int, int, bool)>();

  int spine_physics_constraint_inertia_timeline_get_constraint_index(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_get_constraint_index');
  late final _spine_physics_constraint_inertia_timeline_get_constraint_index =
      _spine_physics_constraint_inertia_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_inertia_timeline)>();

  void spine_physics_constraint_inertia_timeline_set_constraint_index(
    spine_physics_constraint_inertia_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_inertia_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_inertia_timeline, ffi.Int)>>(
          'spine_physics_constraint_inertia_timeline_set_constraint_index');
  late final _spine_physics_constraint_inertia_timeline_set_constraint_index =
      _spine_physics_constraint_inertia_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_physics_constraint_inertia_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_physics_constraint_inertia_timeline_set_frame(
    spine_physics_constraint_inertia_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_inertia_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_inertia_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_inertia_timeline_set_frame');
  late final _spine_physics_constraint_inertia_timeline_set_frame =
      _spine_physics_constraint_inertia_timeline_set_framePtr
          .asFunction<void Function(spine_physics_constraint_inertia_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_physics_constraint_inertia_timeline_get_curve_value(
    spine_physics_constraint_inertia_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_inertia_timeline, ffi.Float)>>(
          'spine_physics_constraint_inertia_timeline_get_curve_value');
  late final _spine_physics_constraint_inertia_timeline_get_curve_value =
      _spine_physics_constraint_inertia_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_physics_constraint_inertia_timeline, double)>();

  double spine_physics_constraint_inertia_timeline_get_relative_value(
    spine_physics_constraint_inertia_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_inertia_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_inertia_timeline_get_relative_value');
  late final _spine_physics_constraint_inertia_timeline_get_relative_value =
      _spine_physics_constraint_inertia_timeline_get_relative_valuePtr.asFunction<
          double Function(spine_physics_constraint_inertia_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_inertia_timeline_get_absolute_value_1(
    spine_physics_constraint_inertia_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_inertia_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_inertia_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_inertia_timeline_get_absolute_value_1 =
      _spine_physics_constraint_inertia_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(spine_physics_constraint_inertia_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_inertia_timeline_get_absolute_value_2(
    spine_physics_constraint_inertia_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_inertia_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_inertia_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_inertia_timeline_get_absolute_value_2 =
      _spine_physics_constraint_inertia_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_physics_constraint_inertia_timeline, double, double, int, double, double, double)>();

  double spine_physics_constraint_inertia_timeline_get_scale_value(
    spine_physics_constraint_inertia_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_inertia_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_inertia_timeline_get_scale_value');
  late final _spine_physics_constraint_inertia_timeline_get_scale_value =
      _spine_physics_constraint_inertia_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_inertia_timeline, double, double, int, int, double, double)>();

  void spine_physics_constraint_inertia_timeline_set_linear(
    spine_physics_constraint_inertia_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_inertia_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_inertia_timeline, ffi.Size)>>(
          'spine_physics_constraint_inertia_timeline_set_linear');
  late final _spine_physics_constraint_inertia_timeline_set_linear =
      _spine_physics_constraint_inertia_timeline_set_linearPtr
          .asFunction<void Function(spine_physics_constraint_inertia_timeline, int)>();

  void spine_physics_constraint_inertia_timeline_set_stepped(
    spine_physics_constraint_inertia_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_inertia_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_inertia_timeline, ffi.Size)>>(
          'spine_physics_constraint_inertia_timeline_set_stepped');
  late final _spine_physics_constraint_inertia_timeline_set_stepped =
      _spine_physics_constraint_inertia_timeline_set_steppedPtr
          .asFunction<void Function(spine_physics_constraint_inertia_timeline, int)>();

  void spine_physics_constraint_inertia_timeline_set_bezier(
    spine_physics_constraint_inertia_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_inertia_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_inertia_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_inertia_timeline_set_bezier');
  late final _spine_physics_constraint_inertia_timeline_set_bezier =
      _spine_physics_constraint_inertia_timeline_set_bezierPtr.asFunction<
          void Function(spine_physics_constraint_inertia_timeline, int, int, double, double, double, double, double,
              double, double, double, double)>();

  double spine_physics_constraint_inertia_timeline_get_bezier_value(
    spine_physics_constraint_inertia_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_inertia_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_physics_constraint_inertia_timeline_get_bezier_value');
  late final _spine_physics_constraint_inertia_timeline_get_bezier_value =
      _spine_physics_constraint_inertia_timeline_get_bezier_valuePtr
          .asFunction<double Function(spine_physics_constraint_inertia_timeline, double, int, int, int)>();

  spine_array_float spine_physics_constraint_inertia_timeline_get_curves(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_get_curves');
  late final _spine_physics_constraint_inertia_timeline_get_curves =
      _spine_physics_constraint_inertia_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_physics_constraint_inertia_timeline)>();

  int spine_physics_constraint_inertia_timeline_get_frame_entries(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_get_frame_entries');
  late final _spine_physics_constraint_inertia_timeline_get_frame_entries =
      _spine_physics_constraint_inertia_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_inertia_timeline)>();

  int spine_physics_constraint_inertia_timeline_get_frame_count(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_get_frame_count');
  late final _spine_physics_constraint_inertia_timeline_get_frame_count =
      _spine_physics_constraint_inertia_timeline_get_frame_countPtr
          .asFunction<int Function(spine_physics_constraint_inertia_timeline)>();

  spine_array_float spine_physics_constraint_inertia_timeline_get_frames(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_get_frames');
  late final _spine_physics_constraint_inertia_timeline_get_frames =
      _spine_physics_constraint_inertia_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_physics_constraint_inertia_timeline)>();

  double spine_physics_constraint_inertia_timeline_get_duration(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_get_duration');
  late final _spine_physics_constraint_inertia_timeline_get_duration =
      _spine_physics_constraint_inertia_timeline_get_durationPtr
          .asFunction<double Function(spine_physics_constraint_inertia_timeline)>();

  spine_array_property_id spine_physics_constraint_inertia_timeline_get_property_ids(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_get_property_ids');
  late final _spine_physics_constraint_inertia_timeline_get_property_ids =
      _spine_physics_constraint_inertia_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_physics_constraint_inertia_timeline)>();

  spine_rtti spine_physics_constraint_inertia_timeline_rtti() {
    return _spine_physics_constraint_inertia_timeline_rtti();
  }

  late final _spine_physics_constraint_inertia_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_physics_constraint_inertia_timeline_rtti');
  late final _spine_physics_constraint_inertia_timeline_rtti =
      _spine_physics_constraint_inertia_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_physics_constraint_mass_timeline spine_physics_constraint_mass_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_mass_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_mass_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_mass_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_physics_constraint_mass_timeline_create');
  late final _spine_physics_constraint_mass_timeline_create = _spine_physics_constraint_mass_timeline_createPtr
      .asFunction<spine_physics_constraint_mass_timeline Function(int, int, int)>();

  void spine_physics_constraint_mass_timeline_dispose(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_dispose');
  late final _spine_physics_constraint_mass_timeline_dispose = _spine_physics_constraint_mass_timeline_disposePtr
      .asFunction<void Function(spine_physics_constraint_mass_timeline)>();

  spine_rtti spine_physics_constraint_mass_timeline_get_rtti(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_get_rtti');
  late final _spine_physics_constraint_mass_timeline_get_rtti = _spine_physics_constraint_mass_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_physics_constraint_mass_timeline)>();

  void spine_physics_constraint_mass_timeline_apply(
    spine_physics_constraint_mass_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_mass_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_mass_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_mass_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_mass_timeline_apply');
  late final _spine_physics_constraint_mass_timeline_apply =
      _spine_physics_constraint_mass_timeline_applyPtr.asFunction<
          void Function(spine_physics_constraint_mass_timeline, spine_skeleton, double, double, spine_array_event,
              double, int, int, bool)>();

  int spine_physics_constraint_mass_timeline_get_constraint_index(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_get_constraint_index');
  late final _spine_physics_constraint_mass_timeline_get_constraint_index =
      _spine_physics_constraint_mass_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_mass_timeline)>();

  void spine_physics_constraint_mass_timeline_set_constraint_index(
    spine_physics_constraint_mass_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_mass_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_mass_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_mass_timeline, ffi.Int)>>(
          'spine_physics_constraint_mass_timeline_set_constraint_index');
  late final _spine_physics_constraint_mass_timeline_set_constraint_index =
      _spine_physics_constraint_mass_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_physics_constraint_mass_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_physics_constraint_mass_timeline_set_frame(
    spine_physics_constraint_mass_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_mass_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_mass_timeline_set_framePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_physics_constraint_mass_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
      'spine_physics_constraint_mass_timeline_set_frame');
  late final _spine_physics_constraint_mass_timeline_set_frame = _spine_physics_constraint_mass_timeline_set_framePtr
      .asFunction<void Function(spine_physics_constraint_mass_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_physics_constraint_mass_timeline_get_curve_value(
    spine_physics_constraint_mass_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_mass_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_mass_timeline, ffi.Float)>>(
          'spine_physics_constraint_mass_timeline_get_curve_value');
  late final _spine_physics_constraint_mass_timeline_get_curve_value =
      _spine_physics_constraint_mass_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_physics_constraint_mass_timeline, double)>();

  double spine_physics_constraint_mass_timeline_get_relative_value(
    spine_physics_constraint_mass_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_mass_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_mass_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_mass_timeline_get_relative_value');
  late final _spine_physics_constraint_mass_timeline_get_relative_value =
      _spine_physics_constraint_mass_timeline_get_relative_valuePtr
          .asFunction<double Function(spine_physics_constraint_mass_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_mass_timeline_get_absolute_value_1(
    spine_physics_constraint_mass_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_mass_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_mass_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_mass_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_mass_timeline_get_absolute_value_1 =
      _spine_physics_constraint_mass_timeline_get_absolute_value_1Ptr
          .asFunction<double Function(spine_physics_constraint_mass_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_mass_timeline_get_absolute_value_2(
    spine_physics_constraint_mass_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_mass_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_mass_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_mass_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_mass_timeline_get_absolute_value_2 =
      _spine_physics_constraint_mass_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_physics_constraint_mass_timeline, double, double, int, double, double, double)>();

  double spine_physics_constraint_mass_timeline_get_scale_value(
    spine_physics_constraint_mass_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_mass_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_mass_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_mass_timeline_get_scale_value');
  late final _spine_physics_constraint_mass_timeline_get_scale_value =
      _spine_physics_constraint_mass_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_mass_timeline, double, double, int, int, double, double)>();

  void spine_physics_constraint_mass_timeline_set_linear(
    spine_physics_constraint_mass_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_mass_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_mass_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_mass_timeline, ffi.Size)>>(
          'spine_physics_constraint_mass_timeline_set_linear');
  late final _spine_physics_constraint_mass_timeline_set_linear = _spine_physics_constraint_mass_timeline_set_linearPtr
      .asFunction<void Function(spine_physics_constraint_mass_timeline, int)>();

  void spine_physics_constraint_mass_timeline_set_stepped(
    spine_physics_constraint_mass_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_mass_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_mass_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_mass_timeline, ffi.Size)>>(
          'spine_physics_constraint_mass_timeline_set_stepped');
  late final _spine_physics_constraint_mass_timeline_set_stepped =
      _spine_physics_constraint_mass_timeline_set_steppedPtr
          .asFunction<void Function(spine_physics_constraint_mass_timeline, int)>();

  void spine_physics_constraint_mass_timeline_set_bezier(
    spine_physics_constraint_mass_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_mass_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_mass_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_mass_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_mass_timeline_set_bezier');
  late final _spine_physics_constraint_mass_timeline_set_bezier =
      _spine_physics_constraint_mass_timeline_set_bezierPtr.asFunction<
          void Function(spine_physics_constraint_mass_timeline, int, int, double, double, double, double, double,
              double, double, double, double)>();

  double spine_physics_constraint_mass_timeline_get_bezier_value(
    spine_physics_constraint_mass_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_mass_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_mass_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_physics_constraint_mass_timeline_get_bezier_value');
  late final _spine_physics_constraint_mass_timeline_get_bezier_value =
      _spine_physics_constraint_mass_timeline_get_bezier_valuePtr
          .asFunction<double Function(spine_physics_constraint_mass_timeline, double, int, int, int)>();

  spine_array_float spine_physics_constraint_mass_timeline_get_curves(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_get_curves');
  late final _spine_physics_constraint_mass_timeline_get_curves = _spine_physics_constraint_mass_timeline_get_curvesPtr
      .asFunction<spine_array_float Function(spine_physics_constraint_mass_timeline)>();

  int spine_physics_constraint_mass_timeline_get_frame_entries(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_get_frame_entries');
  late final _spine_physics_constraint_mass_timeline_get_frame_entries =
      _spine_physics_constraint_mass_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_mass_timeline)>();

  int spine_physics_constraint_mass_timeline_get_frame_count(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_get_frame_count');
  late final _spine_physics_constraint_mass_timeline_get_frame_count =
      _spine_physics_constraint_mass_timeline_get_frame_countPtr
          .asFunction<int Function(spine_physics_constraint_mass_timeline)>();

  spine_array_float spine_physics_constraint_mass_timeline_get_frames(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_get_frames');
  late final _spine_physics_constraint_mass_timeline_get_frames = _spine_physics_constraint_mass_timeline_get_framesPtr
      .asFunction<spine_array_float Function(spine_physics_constraint_mass_timeline)>();

  double spine_physics_constraint_mass_timeline_get_duration(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_get_duration');
  late final _spine_physics_constraint_mass_timeline_get_duration =
      _spine_physics_constraint_mass_timeline_get_durationPtr
          .asFunction<double Function(spine_physics_constraint_mass_timeline)>();

  spine_array_property_id spine_physics_constraint_mass_timeline_get_property_ids(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_get_property_ids');
  late final _spine_physics_constraint_mass_timeline_get_property_ids =
      _spine_physics_constraint_mass_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_physics_constraint_mass_timeline)>();

  spine_rtti spine_physics_constraint_mass_timeline_rtti() {
    return _spine_physics_constraint_mass_timeline_rtti();
  }

  late final _spine_physics_constraint_mass_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_physics_constraint_mass_timeline_rtti');
  late final _spine_physics_constraint_mass_timeline_rtti =
      _spine_physics_constraint_mass_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_physics_constraint_mix_timeline spine_physics_constraint_mix_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_mix_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_mix_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_mix_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_physics_constraint_mix_timeline_create');
  late final _spine_physics_constraint_mix_timeline_create = _spine_physics_constraint_mix_timeline_createPtr
      .asFunction<spine_physics_constraint_mix_timeline Function(int, int, int)>();

  void spine_physics_constraint_mix_timeline_dispose(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_dispose');
  late final _spine_physics_constraint_mix_timeline_dispose = _spine_physics_constraint_mix_timeline_disposePtr
      .asFunction<void Function(spine_physics_constraint_mix_timeline)>();

  spine_rtti spine_physics_constraint_mix_timeline_get_rtti(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_get_rtti');
  late final _spine_physics_constraint_mix_timeline_get_rtti = _spine_physics_constraint_mix_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_physics_constraint_mix_timeline)>();

  void spine_physics_constraint_mix_timeline_apply(
    spine_physics_constraint_mix_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_mix_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_mix_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_mix_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_mix_timeline_apply');
  late final _spine_physics_constraint_mix_timeline_apply = _spine_physics_constraint_mix_timeline_applyPtr.asFunction<
      void Function(spine_physics_constraint_mix_timeline, spine_skeleton, double, double, spine_array_event, double,
          int, int, bool)>();

  int spine_physics_constraint_mix_timeline_get_constraint_index(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_get_constraint_index');
  late final _spine_physics_constraint_mix_timeline_get_constraint_index =
      _spine_physics_constraint_mix_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_mix_timeline)>();

  void spine_physics_constraint_mix_timeline_set_constraint_index(
    spine_physics_constraint_mix_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_mix_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_mix_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_mix_timeline, ffi.Int)>>(
          'spine_physics_constraint_mix_timeline_set_constraint_index');
  late final _spine_physics_constraint_mix_timeline_set_constraint_index =
      _spine_physics_constraint_mix_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_physics_constraint_mix_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_physics_constraint_mix_timeline_set_frame(
    spine_physics_constraint_mix_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_mix_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_mix_timeline_set_framePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_mix_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
      'spine_physics_constraint_mix_timeline_set_frame');
  late final _spine_physics_constraint_mix_timeline_set_frame = _spine_physics_constraint_mix_timeline_set_framePtr
      .asFunction<void Function(spine_physics_constraint_mix_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_physics_constraint_mix_timeline_get_curve_value(
    spine_physics_constraint_mix_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_mix_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_mix_timeline, ffi.Float)>>(
          'spine_physics_constraint_mix_timeline_get_curve_value');
  late final _spine_physics_constraint_mix_timeline_get_curve_value =
      _spine_physics_constraint_mix_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_physics_constraint_mix_timeline, double)>();

  double spine_physics_constraint_mix_timeline_get_relative_value(
    spine_physics_constraint_mix_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_mix_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_mix_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_mix_timeline_get_relative_value');
  late final _spine_physics_constraint_mix_timeline_get_relative_value =
      _spine_physics_constraint_mix_timeline_get_relative_valuePtr
          .asFunction<double Function(spine_physics_constraint_mix_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_mix_timeline_get_absolute_value_1(
    spine_physics_constraint_mix_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_mix_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_mix_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_mix_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_mix_timeline_get_absolute_value_1 =
      _spine_physics_constraint_mix_timeline_get_absolute_value_1Ptr
          .asFunction<double Function(spine_physics_constraint_mix_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_mix_timeline_get_absolute_value_2(
    spine_physics_constraint_mix_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_mix_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_mix_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_mix_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_mix_timeline_get_absolute_value_2 =
      _spine_physics_constraint_mix_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_physics_constraint_mix_timeline, double, double, int, double, double, double)>();

  double spine_physics_constraint_mix_timeline_get_scale_value(
    spine_physics_constraint_mix_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_mix_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_mix_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_mix_timeline_get_scale_value');
  late final _spine_physics_constraint_mix_timeline_get_scale_value =
      _spine_physics_constraint_mix_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_mix_timeline, double, double, int, int, double, double)>();

  void spine_physics_constraint_mix_timeline_set_linear(
    spine_physics_constraint_mix_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_mix_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_mix_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_mix_timeline, ffi.Size)>>(
          'spine_physics_constraint_mix_timeline_set_linear');
  late final _spine_physics_constraint_mix_timeline_set_linear = _spine_physics_constraint_mix_timeline_set_linearPtr
      .asFunction<void Function(spine_physics_constraint_mix_timeline, int)>();

  void spine_physics_constraint_mix_timeline_set_stepped(
    spine_physics_constraint_mix_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_mix_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_mix_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_mix_timeline, ffi.Size)>>(
          'spine_physics_constraint_mix_timeline_set_stepped');
  late final _spine_physics_constraint_mix_timeline_set_stepped = _spine_physics_constraint_mix_timeline_set_steppedPtr
      .asFunction<void Function(spine_physics_constraint_mix_timeline, int)>();

  void spine_physics_constraint_mix_timeline_set_bezier(
    spine_physics_constraint_mix_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_mix_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_mix_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_mix_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_mix_timeline_set_bezier');
  late final _spine_physics_constraint_mix_timeline_set_bezier =
      _spine_physics_constraint_mix_timeline_set_bezierPtr.asFunction<
          void Function(spine_physics_constraint_mix_timeline, int, int, double, double, double, double, double, double,
              double, double, double)>();

  double spine_physics_constraint_mix_timeline_get_bezier_value(
    spine_physics_constraint_mix_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_mix_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_mix_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_physics_constraint_mix_timeline_get_bezier_value');
  late final _spine_physics_constraint_mix_timeline_get_bezier_value =
      _spine_physics_constraint_mix_timeline_get_bezier_valuePtr
          .asFunction<double Function(spine_physics_constraint_mix_timeline, double, int, int, int)>();

  spine_array_float spine_physics_constraint_mix_timeline_get_curves(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_get_curves');
  late final _spine_physics_constraint_mix_timeline_get_curves = _spine_physics_constraint_mix_timeline_get_curvesPtr
      .asFunction<spine_array_float Function(spine_physics_constraint_mix_timeline)>();

  int spine_physics_constraint_mix_timeline_get_frame_entries(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_get_frame_entries');
  late final _spine_physics_constraint_mix_timeline_get_frame_entries =
      _spine_physics_constraint_mix_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_mix_timeline)>();

  int spine_physics_constraint_mix_timeline_get_frame_count(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_get_frame_count');
  late final _spine_physics_constraint_mix_timeline_get_frame_count =
      _spine_physics_constraint_mix_timeline_get_frame_countPtr
          .asFunction<int Function(spine_physics_constraint_mix_timeline)>();

  spine_array_float spine_physics_constraint_mix_timeline_get_frames(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_get_frames');
  late final _spine_physics_constraint_mix_timeline_get_frames = _spine_physics_constraint_mix_timeline_get_framesPtr
      .asFunction<spine_array_float Function(spine_physics_constraint_mix_timeline)>();

  double spine_physics_constraint_mix_timeline_get_duration(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_get_duration');
  late final _spine_physics_constraint_mix_timeline_get_duration =
      _spine_physics_constraint_mix_timeline_get_durationPtr
          .asFunction<double Function(spine_physics_constraint_mix_timeline)>();

  spine_array_property_id spine_physics_constraint_mix_timeline_get_property_ids(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_get_property_ids');
  late final _spine_physics_constraint_mix_timeline_get_property_ids =
      _spine_physics_constraint_mix_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_physics_constraint_mix_timeline)>();

  spine_rtti spine_physics_constraint_mix_timeline_rtti() {
    return _spine_physics_constraint_mix_timeline_rtti();
  }

  late final _spine_physics_constraint_mix_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_physics_constraint_mix_timeline_rtti');
  late final _spine_physics_constraint_mix_timeline_rtti =
      _spine_physics_constraint_mix_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_physics_constraint_pose spine_physics_constraint_pose_create() {
    return _spine_physics_constraint_pose_create();
  }

  late final _spine_physics_constraint_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_pose Function()>>('spine_physics_constraint_pose_create');
  late final _spine_physics_constraint_pose_create =
      _spine_physics_constraint_pose_createPtr.asFunction<spine_physics_constraint_pose Function()>();

  void spine_physics_constraint_pose_dispose(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_pose_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_pose)>>(
          'spine_physics_constraint_pose_dispose');
  late final _spine_physics_constraint_pose_dispose =
      _spine_physics_constraint_pose_disposePtr.asFunction<void Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set(
    spine_physics_constraint_pose self,
    spine_physics_constraint_pose pose,
  ) {
    return _spine_physics_constraint_pose_set(
      self,
      pose,
    );
  }

  late final _spine_physics_constraint_pose_setPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_pose, spine_physics_constraint_pose)>>(
          'spine_physics_constraint_pose_set');
  late final _spine_physics_constraint_pose_set = _spine_physics_constraint_pose_setPtr
      .asFunction<void Function(spine_physics_constraint_pose, spine_physics_constraint_pose)>();

  double spine_physics_constraint_pose_get_inertia(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_inertia(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_inertiaPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
          'spine_physics_constraint_pose_get_inertia');
  late final _spine_physics_constraint_pose_get_inertia =
      _spine_physics_constraint_pose_get_inertiaPtr.asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_inertia(
    spine_physics_constraint_pose self,
    double inertia,
  ) {
    return _spine_physics_constraint_pose_set_inertia(
      self,
      inertia,
    );
  }

  late final _spine_physics_constraint_pose_set_inertiaPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_pose, ffi.Float)>>(
          'spine_physics_constraint_pose_set_inertia');
  late final _spine_physics_constraint_pose_set_inertia =
      _spine_physics_constraint_pose_set_inertiaPtr.asFunction<void Function(spine_physics_constraint_pose, double)>();

  double spine_physics_constraint_pose_get_strength(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_strength(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_strengthPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
          'spine_physics_constraint_pose_get_strength');
  late final _spine_physics_constraint_pose_get_strength =
      _spine_physics_constraint_pose_get_strengthPtr.asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_strength(
    spine_physics_constraint_pose self,
    double strength,
  ) {
    return _spine_physics_constraint_pose_set_strength(
      self,
      strength,
    );
  }

  late final _spine_physics_constraint_pose_set_strengthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_pose, ffi.Float)>>(
          'spine_physics_constraint_pose_set_strength');
  late final _spine_physics_constraint_pose_set_strength =
      _spine_physics_constraint_pose_set_strengthPtr.asFunction<void Function(spine_physics_constraint_pose, double)>();

  double spine_physics_constraint_pose_get_damping(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_damping(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_dampingPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
          'spine_physics_constraint_pose_get_damping');
  late final _spine_physics_constraint_pose_get_damping =
      _spine_physics_constraint_pose_get_dampingPtr.asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_damping(
    spine_physics_constraint_pose self,
    double damping,
  ) {
    return _spine_physics_constraint_pose_set_damping(
      self,
      damping,
    );
  }

  late final _spine_physics_constraint_pose_set_dampingPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_pose, ffi.Float)>>(
          'spine_physics_constraint_pose_set_damping');
  late final _spine_physics_constraint_pose_set_damping =
      _spine_physics_constraint_pose_set_dampingPtr.asFunction<void Function(spine_physics_constraint_pose, double)>();

  double spine_physics_constraint_pose_get_mass_inverse(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_mass_inverse(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_mass_inversePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
          'spine_physics_constraint_pose_get_mass_inverse');
  late final _spine_physics_constraint_pose_get_mass_inverse =
      _spine_physics_constraint_pose_get_mass_inversePtr.asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_mass_inverse(
    spine_physics_constraint_pose self,
    double massInverse,
  ) {
    return _spine_physics_constraint_pose_set_mass_inverse(
      self,
      massInverse,
    );
  }

  late final _spine_physics_constraint_pose_set_mass_inversePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_pose, ffi.Float)>>(
          'spine_physics_constraint_pose_set_mass_inverse');
  late final _spine_physics_constraint_pose_set_mass_inverse = _spine_physics_constraint_pose_set_mass_inversePtr
      .asFunction<void Function(spine_physics_constraint_pose, double)>();

  double spine_physics_constraint_pose_get_wind(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_wind(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_windPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
          'spine_physics_constraint_pose_get_wind');
  late final _spine_physics_constraint_pose_get_wind =
      _spine_physics_constraint_pose_get_windPtr.asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_wind(
    spine_physics_constraint_pose self,
    double wind,
  ) {
    return _spine_physics_constraint_pose_set_wind(
      self,
      wind,
    );
  }

  late final _spine_physics_constraint_pose_set_windPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_pose, ffi.Float)>>(
          'spine_physics_constraint_pose_set_wind');
  late final _spine_physics_constraint_pose_set_wind =
      _spine_physics_constraint_pose_set_windPtr.asFunction<void Function(spine_physics_constraint_pose, double)>();

  double spine_physics_constraint_pose_get_gravity(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_gravity(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_gravityPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
          'spine_physics_constraint_pose_get_gravity');
  late final _spine_physics_constraint_pose_get_gravity =
      _spine_physics_constraint_pose_get_gravityPtr.asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_gravity(
    spine_physics_constraint_pose self,
    double gravity,
  ) {
    return _spine_physics_constraint_pose_set_gravity(
      self,
      gravity,
    );
  }

  late final _spine_physics_constraint_pose_set_gravityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_pose, ffi.Float)>>(
          'spine_physics_constraint_pose_set_gravity');
  late final _spine_physics_constraint_pose_set_gravity =
      _spine_physics_constraint_pose_set_gravityPtr.asFunction<void Function(spine_physics_constraint_pose, double)>();

  /// A percentage (0-1) that controls the mix between the constrained and
  /// unconstrained poses.
  double spine_physics_constraint_pose_get_mix(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_mix(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
          'spine_physics_constraint_pose_get_mix');
  late final _spine_physics_constraint_pose_get_mix =
      _spine_physics_constraint_pose_get_mixPtr.asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_mix(
    spine_physics_constraint_pose self,
    double mix,
  ) {
    return _spine_physics_constraint_pose_set_mix(
      self,
      mix,
    );
  }

  late final _spine_physics_constraint_pose_set_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_pose, ffi.Float)>>(
          'spine_physics_constraint_pose_set_mix');
  late final _spine_physics_constraint_pose_set_mix =
      _spine_physics_constraint_pose_set_mixPtr.asFunction<void Function(spine_physics_constraint_pose, double)>();

  /// @param constraintIndex -1 for all physics constraints in the skeleton.
  spine_physics_constraint_reset_timeline spine_physics_constraint_reset_timeline_create(
    int frameCount,
    int constraintIndex,
  ) {
    return _spine_physics_constraint_reset_timeline_create(
      frameCount,
      constraintIndex,
    );
  }

  late final _spine_physics_constraint_reset_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_reset_timeline Function(ffi.Size, ffi.Int)>>(
          'spine_physics_constraint_reset_timeline_create');
  late final _spine_physics_constraint_reset_timeline_create = _spine_physics_constraint_reset_timeline_createPtr
      .asFunction<spine_physics_constraint_reset_timeline Function(int, int)>();

  void spine_physics_constraint_reset_timeline_dispose(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_dispose');
  late final _spine_physics_constraint_reset_timeline_dispose = _spine_physics_constraint_reset_timeline_disposePtr
      .asFunction<void Function(spine_physics_constraint_reset_timeline)>();

  spine_rtti spine_physics_constraint_reset_timeline_get_rtti(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_get_rtti');
  late final _spine_physics_constraint_reset_timeline_get_rtti = _spine_physics_constraint_reset_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_physics_constraint_reset_timeline)>();

  void spine_physics_constraint_reset_timeline_apply(
    spine_physics_constraint_reset_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_reset_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_reset_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_reset_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_reset_timeline_apply');
  late final _spine_physics_constraint_reset_timeline_apply =
      _spine_physics_constraint_reset_timeline_applyPtr.asFunction<
          void Function(spine_physics_constraint_reset_timeline, spine_skeleton, double, double, spine_array_event,
              double, int, int, bool)>();

  int spine_physics_constraint_reset_timeline_get_frame_count(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_get_frame_count');
  late final _spine_physics_constraint_reset_timeline_get_frame_count =
      _spine_physics_constraint_reset_timeline_get_frame_countPtr
          .asFunction<int Function(spine_physics_constraint_reset_timeline)>();

  int spine_physics_constraint_reset_timeline_get_constraint_index(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_get_constraint_index');
  late final _spine_physics_constraint_reset_timeline_get_constraint_index =
      _spine_physics_constraint_reset_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_reset_timeline)>();

  void spine_physics_constraint_reset_timeline_set_constraint_index(
    spine_physics_constraint_reset_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_reset_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_reset_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_reset_timeline, ffi.Int)>>(
          'spine_physics_constraint_reset_timeline_set_constraint_index');
  late final _spine_physics_constraint_reset_timeline_set_constraint_index =
      _spine_physics_constraint_reset_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_physics_constraint_reset_timeline, int)>();

  /// Sets the time for the specified frame.
  void spine_physics_constraint_reset_timeline_set_frame(
    spine_physics_constraint_reset_timeline self,
    int frame,
    double time,
  ) {
    return _spine_physics_constraint_reset_timeline_set_frame(
      self,
      frame,
      time,
    );
  }

  late final _spine_physics_constraint_reset_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_reset_timeline, ffi.Int, ffi.Float)>>(
          'spine_physics_constraint_reset_timeline_set_frame');
  late final _spine_physics_constraint_reset_timeline_set_frame = _spine_physics_constraint_reset_timeline_set_framePtr
      .asFunction<void Function(spine_physics_constraint_reset_timeline, int, double)>();

  int spine_physics_constraint_reset_timeline_get_frame_entries(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_get_frame_entries');
  late final _spine_physics_constraint_reset_timeline_get_frame_entries =
      _spine_physics_constraint_reset_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_reset_timeline)>();

  spine_array_float spine_physics_constraint_reset_timeline_get_frames(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_get_frames');
  late final _spine_physics_constraint_reset_timeline_get_frames =
      _spine_physics_constraint_reset_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_physics_constraint_reset_timeline)>();

  double spine_physics_constraint_reset_timeline_get_duration(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_get_duration');
  late final _spine_physics_constraint_reset_timeline_get_duration =
      _spine_physics_constraint_reset_timeline_get_durationPtr
          .asFunction<double Function(spine_physics_constraint_reset_timeline)>();

  spine_array_property_id spine_physics_constraint_reset_timeline_get_property_ids(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_get_property_ids');
  late final _spine_physics_constraint_reset_timeline_get_property_ids =
      _spine_physics_constraint_reset_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_physics_constraint_reset_timeline)>();

  spine_rtti spine_physics_constraint_reset_timeline_rtti() {
    return _spine_physics_constraint_reset_timeline_rtti();
  }

  late final _spine_physics_constraint_reset_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_physics_constraint_reset_timeline_rtti');
  late final _spine_physics_constraint_reset_timeline_rtti =
      _spine_physics_constraint_reset_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_physics_constraint_strength_timeline spine_physics_constraint_strength_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_strength_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_strength_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_strength_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_physics_constraint_strength_timeline_create');
  late final _spine_physics_constraint_strength_timeline_create = _spine_physics_constraint_strength_timeline_createPtr
      .asFunction<spine_physics_constraint_strength_timeline Function(int, int, int)>();

  void spine_physics_constraint_strength_timeline_dispose(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_dispose');
  late final _spine_physics_constraint_strength_timeline_dispose =
      _spine_physics_constraint_strength_timeline_disposePtr
          .asFunction<void Function(spine_physics_constraint_strength_timeline)>();

  spine_rtti spine_physics_constraint_strength_timeline_get_rtti(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_rtti');
  late final _spine_physics_constraint_strength_timeline_get_rtti =
      _spine_physics_constraint_strength_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_physics_constraint_strength_timeline)>();

  void spine_physics_constraint_strength_timeline_apply(
    spine_physics_constraint_strength_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_strength_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_strength_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_strength_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_strength_timeline_apply');
  late final _spine_physics_constraint_strength_timeline_apply =
      _spine_physics_constraint_strength_timeline_applyPtr.asFunction<
          void Function(spine_physics_constraint_strength_timeline, spine_skeleton, double, double, spine_array_event,
              double, int, int, bool)>();

  int spine_physics_constraint_strength_timeline_get_constraint_index(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_constraint_index');
  late final _spine_physics_constraint_strength_timeline_get_constraint_index =
      _spine_physics_constraint_strength_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_strength_timeline)>();

  void spine_physics_constraint_strength_timeline_set_constraint_index(
    spine_physics_constraint_strength_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_strength_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_strength_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_strength_timeline, ffi.Int)>>(
          'spine_physics_constraint_strength_timeline_set_constraint_index');
  late final _spine_physics_constraint_strength_timeline_set_constraint_index =
      _spine_physics_constraint_strength_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_physics_constraint_strength_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_physics_constraint_strength_timeline_set_frame(
    spine_physics_constraint_strength_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_strength_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_strength_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_strength_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_strength_timeline_set_frame');
  late final _spine_physics_constraint_strength_timeline_set_frame =
      _spine_physics_constraint_strength_timeline_set_framePtr
          .asFunction<void Function(spine_physics_constraint_strength_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_physics_constraint_strength_timeline_get_curve_value(
    spine_physics_constraint_strength_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_strength_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_strength_timeline, ffi.Float)>>(
          'spine_physics_constraint_strength_timeline_get_curve_value');
  late final _spine_physics_constraint_strength_timeline_get_curve_value =
      _spine_physics_constraint_strength_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_physics_constraint_strength_timeline, double)>();

  double spine_physics_constraint_strength_timeline_get_relative_value(
    spine_physics_constraint_strength_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_strength_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_strength_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_strength_timeline_get_relative_value');
  late final _spine_physics_constraint_strength_timeline_get_relative_value =
      _spine_physics_constraint_strength_timeline_get_relative_valuePtr.asFunction<
          double Function(spine_physics_constraint_strength_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_strength_timeline_get_absolute_value_1(
    spine_physics_constraint_strength_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_strength_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_strength_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_strength_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_strength_timeline_get_absolute_value_1 =
      _spine_physics_constraint_strength_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(spine_physics_constraint_strength_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_strength_timeline_get_absolute_value_2(
    spine_physics_constraint_strength_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_strength_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_strength_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_strength_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_strength_timeline_get_absolute_value_2 =
      _spine_physics_constraint_strength_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_physics_constraint_strength_timeline, double, double, int, double, double, double)>();

  double spine_physics_constraint_strength_timeline_get_scale_value(
    spine_physics_constraint_strength_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_strength_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_strength_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_strength_timeline_get_scale_value');
  late final _spine_physics_constraint_strength_timeline_get_scale_value =
      _spine_physics_constraint_strength_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_strength_timeline, double, double, int, int, double, double)>();

  void spine_physics_constraint_strength_timeline_set_linear(
    spine_physics_constraint_strength_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_strength_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_strength_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_strength_timeline, ffi.Size)>>(
          'spine_physics_constraint_strength_timeline_set_linear');
  late final _spine_physics_constraint_strength_timeline_set_linear =
      _spine_physics_constraint_strength_timeline_set_linearPtr
          .asFunction<void Function(spine_physics_constraint_strength_timeline, int)>();

  void spine_physics_constraint_strength_timeline_set_stepped(
    spine_physics_constraint_strength_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_strength_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_strength_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_strength_timeline, ffi.Size)>>(
          'spine_physics_constraint_strength_timeline_set_stepped');
  late final _spine_physics_constraint_strength_timeline_set_stepped =
      _spine_physics_constraint_strength_timeline_set_steppedPtr
          .asFunction<void Function(spine_physics_constraint_strength_timeline, int)>();

  void spine_physics_constraint_strength_timeline_set_bezier(
    spine_physics_constraint_strength_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_strength_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_strength_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_strength_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_strength_timeline_set_bezier');
  late final _spine_physics_constraint_strength_timeline_set_bezier =
      _spine_physics_constraint_strength_timeline_set_bezierPtr.asFunction<
          void Function(spine_physics_constraint_strength_timeline, int, int, double, double, double, double, double,
              double, double, double, double)>();

  double spine_physics_constraint_strength_timeline_get_bezier_value(
    spine_physics_constraint_strength_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_strength_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_strength_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_physics_constraint_strength_timeline_get_bezier_value');
  late final _spine_physics_constraint_strength_timeline_get_bezier_value =
      _spine_physics_constraint_strength_timeline_get_bezier_valuePtr
          .asFunction<double Function(spine_physics_constraint_strength_timeline, double, int, int, int)>();

  spine_array_float spine_physics_constraint_strength_timeline_get_curves(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_curves');
  late final _spine_physics_constraint_strength_timeline_get_curves =
      _spine_physics_constraint_strength_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_physics_constraint_strength_timeline)>();

  int spine_physics_constraint_strength_timeline_get_frame_entries(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_frame_entries');
  late final _spine_physics_constraint_strength_timeline_get_frame_entries =
      _spine_physics_constraint_strength_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_strength_timeline)>();

  int spine_physics_constraint_strength_timeline_get_frame_count(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_frame_count');
  late final _spine_physics_constraint_strength_timeline_get_frame_count =
      _spine_physics_constraint_strength_timeline_get_frame_countPtr
          .asFunction<int Function(spine_physics_constraint_strength_timeline)>();

  spine_array_float spine_physics_constraint_strength_timeline_get_frames(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_frames');
  late final _spine_physics_constraint_strength_timeline_get_frames =
      _spine_physics_constraint_strength_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_physics_constraint_strength_timeline)>();

  double spine_physics_constraint_strength_timeline_get_duration(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_duration');
  late final _spine_physics_constraint_strength_timeline_get_duration =
      _spine_physics_constraint_strength_timeline_get_durationPtr
          .asFunction<double Function(spine_physics_constraint_strength_timeline)>();

  spine_array_property_id spine_physics_constraint_strength_timeline_get_property_ids(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_property_ids');
  late final _spine_physics_constraint_strength_timeline_get_property_ids =
      _spine_physics_constraint_strength_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_physics_constraint_strength_timeline)>();

  spine_rtti spine_physics_constraint_strength_timeline_rtti() {
    return _spine_physics_constraint_strength_timeline_rtti();
  }

  late final _spine_physics_constraint_strength_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_physics_constraint_strength_timeline_rtti');
  late final _spine_physics_constraint_strength_timeline_rtti =
      _spine_physics_constraint_strength_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_physics_constraint_timeline_dispose(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_dispose');
  late final _spine_physics_constraint_timeline_dispose =
      _spine_physics_constraint_timeline_disposePtr.asFunction<void Function(spine_physics_constraint_timeline)>();

  spine_rtti spine_physics_constraint_timeline_get_rtti(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_get_rtti');
  late final _spine_physics_constraint_timeline_get_rtti = _spine_physics_constraint_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_physics_constraint_timeline)>();

  void spine_physics_constraint_timeline_apply(
    spine_physics_constraint_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event,
              ffi.Float, ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_physics_constraint_timeline_apply');
  late final _spine_physics_constraint_timeline_apply = _spine_physics_constraint_timeline_applyPtr.asFunction<
      void Function(spine_physics_constraint_timeline, spine_skeleton, double, double, spine_array_event, double, int,
          int, bool)>();

  int spine_physics_constraint_timeline_get_constraint_index(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_get_constraint_index');
  late final _spine_physics_constraint_timeline_get_constraint_index =
      _spine_physics_constraint_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_timeline)>();

  void spine_physics_constraint_timeline_set_constraint_index(
    spine_physics_constraint_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_timeline, ffi.Int)>>(
          'spine_physics_constraint_timeline_set_constraint_index');
  late final _spine_physics_constraint_timeline_set_constraint_index =
      _spine_physics_constraint_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_physics_constraint_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_physics_constraint_timeline_set_frame(
    spine_physics_constraint_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_timeline_set_frame');
  late final _spine_physics_constraint_timeline_set_frame = _spine_physics_constraint_timeline_set_framePtr
      .asFunction<void Function(spine_physics_constraint_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_physics_constraint_timeline_get_curve_value(
    spine_physics_constraint_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_timeline, ffi.Float)>>(
          'spine_physics_constraint_timeline_get_curve_value');
  late final _spine_physics_constraint_timeline_get_curve_value = _spine_physics_constraint_timeline_get_curve_valuePtr
      .asFunction<double Function(spine_physics_constraint_timeline, double)>();

  double spine_physics_constraint_timeline_get_relative_value(
    spine_physics_constraint_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_timeline_get_relative_value');
  late final _spine_physics_constraint_timeline_get_relative_value =
      _spine_physics_constraint_timeline_get_relative_valuePtr
          .asFunction<double Function(spine_physics_constraint_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_timeline_get_absolute_value_1(
    spine_physics_constraint_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_timeline_get_absolute_value_1 =
      _spine_physics_constraint_timeline_get_absolute_value_1Ptr
          .asFunction<double Function(spine_physics_constraint_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_timeline_get_absolute_value_2(
    spine_physics_constraint_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_timeline_get_absolute_value_2 =
      _spine_physics_constraint_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_physics_constraint_timeline, double, double, int, double, double, double)>();

  double spine_physics_constraint_timeline_get_scale_value(
    spine_physics_constraint_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_timeline_get_scale_value');
  late final _spine_physics_constraint_timeline_get_scale_value = _spine_physics_constraint_timeline_get_scale_valuePtr
      .asFunction<double Function(spine_physics_constraint_timeline, double, double, int, int, double, double)>();

  void spine_physics_constraint_timeline_set_linear(
    spine_physics_constraint_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_timeline, ffi.Size)>>(
          'spine_physics_constraint_timeline_set_linear');
  late final _spine_physics_constraint_timeline_set_linear = _spine_physics_constraint_timeline_set_linearPtr
      .asFunction<void Function(spine_physics_constraint_timeline, int)>();

  void spine_physics_constraint_timeline_set_stepped(
    spine_physics_constraint_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_timeline, ffi.Size)>>(
          'spine_physics_constraint_timeline_set_stepped');
  late final _spine_physics_constraint_timeline_set_stepped = _spine_physics_constraint_timeline_set_steppedPtr
      .asFunction<void Function(spine_physics_constraint_timeline, int)>();

  void spine_physics_constraint_timeline_set_bezier(
    spine_physics_constraint_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_timeline_set_bezier');
  late final _spine_physics_constraint_timeline_set_bezier =
      _spine_physics_constraint_timeline_set_bezierPtr.asFunction<
          void Function(spine_physics_constraint_timeline, int, int, double, double, double, double, double, double,
              double, double, double)>();

  double spine_physics_constraint_timeline_get_bezier_value(
    spine_physics_constraint_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_physics_constraint_timeline_get_bezier_value');
  late final _spine_physics_constraint_timeline_get_bezier_value =
      _spine_physics_constraint_timeline_get_bezier_valuePtr
          .asFunction<double Function(spine_physics_constraint_timeline, double, int, int, int)>();

  spine_array_float spine_physics_constraint_timeline_get_curves(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_get_curves');
  late final _spine_physics_constraint_timeline_get_curves = _spine_physics_constraint_timeline_get_curvesPtr
      .asFunction<spine_array_float Function(spine_physics_constraint_timeline)>();

  int spine_physics_constraint_timeline_get_frame_entries(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_get_frame_entries');
  late final _spine_physics_constraint_timeline_get_frame_entries =
      _spine_physics_constraint_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_timeline)>();

  int spine_physics_constraint_timeline_get_frame_count(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_get_frame_count');
  late final _spine_physics_constraint_timeline_get_frame_count = _spine_physics_constraint_timeline_get_frame_countPtr
      .asFunction<int Function(spine_physics_constraint_timeline)>();

  spine_array_float spine_physics_constraint_timeline_get_frames(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_get_frames');
  late final _spine_physics_constraint_timeline_get_frames = _spine_physics_constraint_timeline_get_framesPtr
      .asFunction<spine_array_float Function(spine_physics_constraint_timeline)>();

  double spine_physics_constraint_timeline_get_duration(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_get_duration');
  late final _spine_physics_constraint_timeline_get_duration = _spine_physics_constraint_timeline_get_durationPtr
      .asFunction<double Function(spine_physics_constraint_timeline)>();

  spine_array_property_id spine_physics_constraint_timeline_get_property_ids(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_get_property_ids');
  late final _spine_physics_constraint_timeline_get_property_ids =
      _spine_physics_constraint_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_physics_constraint_timeline)>();

  spine_rtti spine_physics_constraint_timeline_rtti() {
    return _spine_physics_constraint_timeline_rtti();
  }

  late final _spine_physics_constraint_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_physics_constraint_timeline_rtti');
  late final _spine_physics_constraint_timeline_rtti =
      _spine_physics_constraint_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_physics_constraint_wind_timeline spine_physics_constraint_wind_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_wind_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_wind_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_wind_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_physics_constraint_wind_timeline_create');
  late final _spine_physics_constraint_wind_timeline_create = _spine_physics_constraint_wind_timeline_createPtr
      .asFunction<spine_physics_constraint_wind_timeline Function(int, int, int)>();

  void spine_physics_constraint_wind_timeline_dispose(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_dispose');
  late final _spine_physics_constraint_wind_timeline_dispose = _spine_physics_constraint_wind_timeline_disposePtr
      .asFunction<void Function(spine_physics_constraint_wind_timeline)>();

  spine_rtti spine_physics_constraint_wind_timeline_get_rtti(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_get_rtti');
  late final _spine_physics_constraint_wind_timeline_get_rtti = _spine_physics_constraint_wind_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_physics_constraint_wind_timeline)>();

  void spine_physics_constraint_wind_timeline_apply(
    spine_physics_constraint_wind_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_wind_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_wind_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_wind_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_wind_timeline_apply');
  late final _spine_physics_constraint_wind_timeline_apply =
      _spine_physics_constraint_wind_timeline_applyPtr.asFunction<
          void Function(spine_physics_constraint_wind_timeline, spine_skeleton, double, double, spine_array_event,
              double, int, int, bool)>();

  int spine_physics_constraint_wind_timeline_get_constraint_index(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_get_constraint_index');
  late final _spine_physics_constraint_wind_timeline_get_constraint_index =
      _spine_physics_constraint_wind_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_wind_timeline)>();

  void spine_physics_constraint_wind_timeline_set_constraint_index(
    spine_physics_constraint_wind_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_wind_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_wind_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_wind_timeline, ffi.Int)>>(
          'spine_physics_constraint_wind_timeline_set_constraint_index');
  late final _spine_physics_constraint_wind_timeline_set_constraint_index =
      _spine_physics_constraint_wind_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_physics_constraint_wind_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_physics_constraint_wind_timeline_set_frame(
    spine_physics_constraint_wind_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_wind_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_wind_timeline_set_framePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_physics_constraint_wind_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
      'spine_physics_constraint_wind_timeline_set_frame');
  late final _spine_physics_constraint_wind_timeline_set_frame = _spine_physics_constraint_wind_timeline_set_framePtr
      .asFunction<void Function(spine_physics_constraint_wind_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_physics_constraint_wind_timeline_get_curve_value(
    spine_physics_constraint_wind_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_wind_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_wind_timeline, ffi.Float)>>(
          'spine_physics_constraint_wind_timeline_get_curve_value');
  late final _spine_physics_constraint_wind_timeline_get_curve_value =
      _spine_physics_constraint_wind_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_physics_constraint_wind_timeline, double)>();

  double spine_physics_constraint_wind_timeline_get_relative_value(
    spine_physics_constraint_wind_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_wind_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_wind_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_wind_timeline_get_relative_value');
  late final _spine_physics_constraint_wind_timeline_get_relative_value =
      _spine_physics_constraint_wind_timeline_get_relative_valuePtr
          .asFunction<double Function(spine_physics_constraint_wind_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_wind_timeline_get_absolute_value_1(
    spine_physics_constraint_wind_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_wind_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_wind_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_wind_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_wind_timeline_get_absolute_value_1 =
      _spine_physics_constraint_wind_timeline_get_absolute_value_1Ptr
          .asFunction<double Function(spine_physics_constraint_wind_timeline, double, double, int, double, double)>();

  double spine_physics_constraint_wind_timeline_get_absolute_value_2(
    spine_physics_constraint_wind_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_wind_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_wind_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_wind_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_wind_timeline_get_absolute_value_2 =
      _spine_physics_constraint_wind_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_physics_constraint_wind_timeline, double, double, int, double, double, double)>();

  double spine_physics_constraint_wind_timeline_get_scale_value(
    spine_physics_constraint_wind_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_wind_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_wind_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32,
              ffi.Float, ffi.Float)>>('spine_physics_constraint_wind_timeline_get_scale_value');
  late final _spine_physics_constraint_wind_timeline_get_scale_value =
      _spine_physics_constraint_wind_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_wind_timeline, double, double, int, int, double, double)>();

  void spine_physics_constraint_wind_timeline_set_linear(
    spine_physics_constraint_wind_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_wind_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_wind_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_wind_timeline, ffi.Size)>>(
          'spine_physics_constraint_wind_timeline_set_linear');
  late final _spine_physics_constraint_wind_timeline_set_linear = _spine_physics_constraint_wind_timeline_set_linearPtr
      .asFunction<void Function(spine_physics_constraint_wind_timeline, int)>();

  void spine_physics_constraint_wind_timeline_set_stepped(
    spine_physics_constraint_wind_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_wind_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_wind_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_wind_timeline, ffi.Size)>>(
          'spine_physics_constraint_wind_timeline_set_stepped');
  late final _spine_physics_constraint_wind_timeline_set_stepped =
      _spine_physics_constraint_wind_timeline_set_steppedPtr
          .asFunction<void Function(spine_physics_constraint_wind_timeline, int)>();

  void spine_physics_constraint_wind_timeline_set_bezier(
    spine_physics_constraint_wind_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_wind_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_wind_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_wind_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_wind_timeline_set_bezier');
  late final _spine_physics_constraint_wind_timeline_set_bezier =
      _spine_physics_constraint_wind_timeline_set_bezierPtr.asFunction<
          void Function(spine_physics_constraint_wind_timeline, int, int, double, double, double, double, double,
              double, double, double, double)>();

  double spine_physics_constraint_wind_timeline_get_bezier_value(
    spine_physics_constraint_wind_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_wind_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_wind_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_physics_constraint_wind_timeline_get_bezier_value');
  late final _spine_physics_constraint_wind_timeline_get_bezier_value =
      _spine_physics_constraint_wind_timeline_get_bezier_valuePtr
          .asFunction<double Function(spine_physics_constraint_wind_timeline, double, int, int, int)>();

  spine_array_float spine_physics_constraint_wind_timeline_get_curves(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_get_curves');
  late final _spine_physics_constraint_wind_timeline_get_curves = _spine_physics_constraint_wind_timeline_get_curvesPtr
      .asFunction<spine_array_float Function(spine_physics_constraint_wind_timeline)>();

  int spine_physics_constraint_wind_timeline_get_frame_entries(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_get_frame_entries');
  late final _spine_physics_constraint_wind_timeline_get_frame_entries =
      _spine_physics_constraint_wind_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_wind_timeline)>();

  int spine_physics_constraint_wind_timeline_get_frame_count(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_get_frame_count');
  late final _spine_physics_constraint_wind_timeline_get_frame_count =
      _spine_physics_constraint_wind_timeline_get_frame_countPtr
          .asFunction<int Function(spine_physics_constraint_wind_timeline)>();

  spine_array_float spine_physics_constraint_wind_timeline_get_frames(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_get_frames');
  late final _spine_physics_constraint_wind_timeline_get_frames = _spine_physics_constraint_wind_timeline_get_framesPtr
      .asFunction<spine_array_float Function(spine_physics_constraint_wind_timeline)>();

  double spine_physics_constraint_wind_timeline_get_duration(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_get_duration');
  late final _spine_physics_constraint_wind_timeline_get_duration =
      _spine_physics_constraint_wind_timeline_get_durationPtr
          .asFunction<double Function(spine_physics_constraint_wind_timeline)>();

  spine_array_property_id spine_physics_constraint_wind_timeline_get_property_ids(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_get_property_ids');
  late final _spine_physics_constraint_wind_timeline_get_property_ids =
      _spine_physics_constraint_wind_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_physics_constraint_wind_timeline)>();

  spine_rtti spine_physics_constraint_wind_timeline_rtti() {
    return _spine_physics_constraint_wind_timeline_rtti();
  }

  late final _spine_physics_constraint_wind_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_physics_constraint_wind_timeline_rtti');
  late final _spine_physics_constraint_wind_timeline_rtti =
      _spine_physics_constraint_wind_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_point_attachment spine_point_attachment_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_point_attachment_create(
      name,
    );
  }

  late final _spine_point_attachment_createPtr =
      _lookup<ffi.NativeFunction<spine_point_attachment Function(ffi.Pointer<ffi.Char>)>>(
          'spine_point_attachment_create');
  late final _spine_point_attachment_create =
      _spine_point_attachment_createPtr.asFunction<spine_point_attachment Function(ffi.Pointer<ffi.Char>)>();

  void spine_point_attachment_dispose(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_dispose(
      self,
    );
  }

  late final _spine_point_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_point_attachment)>>('spine_point_attachment_dispose');
  late final _spine_point_attachment_dispose =
      _spine_point_attachment_disposePtr.asFunction<void Function(spine_point_attachment)>();

  spine_rtti spine_point_attachment_get_rtti(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_rtti(
      self,
    );
  }

  late final _spine_point_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_point_attachment)>>('spine_point_attachment_get_rtti');
  late final _spine_point_attachment_get_rtti =
      _spine_point_attachment_get_rttiPtr.asFunction<spine_rtti Function(spine_point_attachment)>();

  double spine_point_attachment_get_x(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_x(
      self,
    );
  }

  late final _spine_point_attachment_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_point_attachment)>>('spine_point_attachment_get_x');
  late final _spine_point_attachment_get_x =
      _spine_point_attachment_get_xPtr.asFunction<double Function(spine_point_attachment)>();

  void spine_point_attachment_set_x(
    spine_point_attachment self,
    double inValue,
  ) {
    return _spine_point_attachment_set_x(
      self,
      inValue,
    );
  }

  late final _spine_point_attachment_set_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_point_attachment, ffi.Float)>>('spine_point_attachment_set_x');
  late final _spine_point_attachment_set_x =
      _spine_point_attachment_set_xPtr.asFunction<void Function(spine_point_attachment, double)>();

  double spine_point_attachment_get_y(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_y(
      self,
    );
  }

  late final _spine_point_attachment_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_point_attachment)>>('spine_point_attachment_get_y');
  late final _spine_point_attachment_get_y =
      _spine_point_attachment_get_yPtr.asFunction<double Function(spine_point_attachment)>();

  void spine_point_attachment_set_y(
    spine_point_attachment self,
    double inValue,
  ) {
    return _spine_point_attachment_set_y(
      self,
      inValue,
    );
  }

  late final _spine_point_attachment_set_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_point_attachment, ffi.Float)>>('spine_point_attachment_set_y');
  late final _spine_point_attachment_set_y =
      _spine_point_attachment_set_yPtr.asFunction<void Function(spine_point_attachment, double)>();

  double spine_point_attachment_get_rotation(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_rotation(
      self,
    );
  }

  late final _spine_point_attachment_get_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_point_attachment)>>('spine_point_attachment_get_rotation');
  late final _spine_point_attachment_get_rotation =
      _spine_point_attachment_get_rotationPtr.asFunction<double Function(spine_point_attachment)>();

  void spine_point_attachment_set_rotation(
    spine_point_attachment self,
    double inValue,
  ) {
    return _spine_point_attachment_set_rotation(
      self,
      inValue,
    );
  }

  late final _spine_point_attachment_set_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_point_attachment, ffi.Float)>>(
          'spine_point_attachment_set_rotation');
  late final _spine_point_attachment_set_rotation =
      _spine_point_attachment_set_rotationPtr.asFunction<void Function(spine_point_attachment, double)>();

  spine_color spine_point_attachment_get_color(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_color(
      self,
    );
  }

  late final _spine_point_attachment_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_point_attachment)>>('spine_point_attachment_get_color');
  late final _spine_point_attachment_get_color =
      _spine_point_attachment_get_colorPtr.asFunction<spine_color Function(spine_point_attachment)>();

  void spine_point_attachment_compute_world_position(
    spine_point_attachment self,
    spine_bone_pose bone,
    ffi.Pointer<ffi.Float> ox,
    ffi.Pointer<ffi.Float> oy,
  ) {
    return _spine_point_attachment_compute_world_position(
      self,
      bone,
      ox,
      oy,
    );
  }

  late final _spine_point_attachment_compute_world_positionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_point_attachment, spine_bone_pose, ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>>('spine_point_attachment_compute_world_position');
  late final _spine_point_attachment_compute_world_position =
      _spine_point_attachment_compute_world_positionPtr.asFunction<
          void Function(spine_point_attachment, spine_bone_pose, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>)>();

  double spine_point_attachment_compute_world_rotation(
    spine_point_attachment self,
    spine_bone_pose bone,
  ) {
    return _spine_point_attachment_compute_world_rotation(
      self,
      bone,
    );
  }

  late final _spine_point_attachment_compute_world_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_point_attachment, spine_bone_pose)>>(
          'spine_point_attachment_compute_world_rotation');
  late final _spine_point_attachment_compute_world_rotation = _spine_point_attachment_compute_world_rotationPtr
      .asFunction<double Function(spine_point_attachment, spine_bone_pose)>();

  spine_attachment spine_point_attachment_copy(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_copy(
      self,
    );
  }

  late final _spine_point_attachment_copyPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_point_attachment)>>('spine_point_attachment_copy');
  late final _spine_point_attachment_copy =
      _spine_point_attachment_copyPtr.asFunction<spine_attachment Function(spine_point_attachment)>();

  ffi.Pointer<ffi.Char> spine_point_attachment_get_name(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_name(
      self,
    );
  }

  late final _spine_point_attachment_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_point_attachment)>>(
          'spine_point_attachment_get_name');
  late final _spine_point_attachment_get_name =
      _spine_point_attachment_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_point_attachment)>();

  int spine_point_attachment_get_ref_count(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_point_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_point_attachment)>>('spine_point_attachment_get_ref_count');
  late final _spine_point_attachment_get_ref_count =
      _spine_point_attachment_get_ref_countPtr.asFunction<int Function(spine_point_attachment)>();

  void spine_point_attachment_reference(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_reference(
      self,
    );
  }

  late final _spine_point_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_point_attachment)>>('spine_point_attachment_reference');
  late final _spine_point_attachment_reference =
      _spine_point_attachment_referencePtr.asFunction<void Function(spine_point_attachment)>();

  void spine_point_attachment_dereference(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_dereference(
      self,
    );
  }

  late final _spine_point_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_point_attachment)>>('spine_point_attachment_dereference');
  late final _spine_point_attachment_dereference =
      _spine_point_attachment_dereferencePtr.asFunction<void Function(spine_point_attachment)>();

  spine_rtti spine_point_attachment_rtti() {
    return _spine_point_attachment_rtti();
  }

  late final _spine_point_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_point_attachment_rtti');
  late final _spine_point_attachment_rtti = _spine_point_attachment_rttiPtr.asFunction<spine_rtti Function()>();

  spine_polygon spine_polygon_create() {
    return _spine_polygon_create();
  }

  late final _spine_polygon_createPtr = _lookup<ffi.NativeFunction<spine_polygon Function()>>('spine_polygon_create');
  late final _spine_polygon_create = _spine_polygon_createPtr.asFunction<spine_polygon Function()>();

  void spine_polygon_dispose(
    spine_polygon self,
  ) {
    return _spine_polygon_dispose(
      self,
    );
  }

  late final _spine_polygon_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_polygon)>>('spine_polygon_dispose');
  late final _spine_polygon_dispose = _spine_polygon_disposePtr.asFunction<void Function(spine_polygon)>();

  spine_array_float spine_polygon_get__vertices(
    spine_polygon self,
  ) {
    return _spine_polygon_get__vertices(
      self,
    );
  }

  late final _spine_polygon_get__verticesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_polygon)>>('spine_polygon_get__vertices');
  late final _spine_polygon_get__vertices =
      _spine_polygon_get__verticesPtr.asFunction<spine_array_float Function(spine_polygon)>();

  void spine_polygon_set__vertices(
    spine_polygon self,
    spine_array_float value,
  ) {
    return _spine_polygon_set__vertices(
      self,
      value,
    );
  }

  late final _spine_polygon_set__verticesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_polygon, spine_array_float)>>('spine_polygon_set__vertices');
  late final _spine_polygon_set__vertices =
      _spine_polygon_set__verticesPtr.asFunction<void Function(spine_polygon, spine_array_float)>();

  int spine_polygon_get__count(
    spine_polygon self,
  ) {
    return _spine_polygon_get__count(
      self,
    );
  }

  late final _spine_polygon_get__countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_polygon)>>('spine_polygon_get__count');
  late final _spine_polygon_get__count = _spine_polygon_get__countPtr.asFunction<int Function(spine_polygon)>();

  void spine_polygon_set__count(
    spine_polygon self,
    int value,
  ) {
    return _spine_polygon_set__count(
      self,
      value,
    );
  }

  late final _spine_polygon_set__countPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_polygon, ffi.Int)>>('spine_polygon_set__count');
  late final _spine_polygon_set__count = _spine_polygon_set__countPtr.asFunction<void Function(spine_polygon, int)>();

  void spine_posed_dispose(
    spine_posed self,
  ) {
    return _spine_posed_dispose(
      self,
    );
  }

  late final _spine_posed_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_posed)>>('spine_posed_dispose');
  late final _spine_posed_dispose = _spine_posed_disposePtr.asFunction<void Function(spine_posed)>();

  void spine_posed_constrained(
    spine_posed self,
  ) {
    return _spine_posed_constrained(
      self,
    );
  }

  late final _spine_posed_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_posed)>>('spine_posed_constrained');
  late final _spine_posed_constrained = _spine_posed_constrainedPtr.asFunction<void Function(spine_posed)>();

  void spine_posed_reset_constrained(
    spine_posed self,
  ) {
    return _spine_posed_reset_constrained(
      self,
    );
  }

  late final _spine_posed_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_posed)>>('spine_posed_reset_constrained');
  late final _spine_posed_reset_constrained =
      _spine_posed_reset_constrainedPtr.asFunction<void Function(spine_posed)>();

  bool spine_posed_is_pose_equal_to_applied(
    spine_posed self,
  ) {
    return _spine_posed_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_posed_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_posed)>>('spine_posed_is_pose_equal_to_applied');
  late final _spine_posed_is_pose_equal_to_applied =
      _spine_posed_is_pose_equal_to_appliedPtr.asFunction<bool Function(spine_posed)>();

  void spine_posed_active_dispose(
    spine_posed_active self,
  ) {
    return _spine_posed_active_dispose(
      self,
    );
  }

  late final _spine_posed_active_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_posed_active)>>('spine_posed_active_dispose');
  late final _spine_posed_active_dispose =
      _spine_posed_active_disposePtr.asFunction<void Function(spine_posed_active)>();

  bool spine_posed_active_is_active(
    spine_posed_active self,
  ) {
    return _spine_posed_active_is_active(
      self,
    );
  }

  late final _spine_posed_active_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_posed_active)>>('spine_posed_active_is_active');
  late final _spine_posed_active_is_active =
      _spine_posed_active_is_activePtr.asFunction<bool Function(spine_posed_active)>();

  void spine_posed_active_set_active(
    spine_posed_active self,
    bool active,
  ) {
    return _spine_posed_active_set_active(
      self,
      active,
    );
  }

  late final _spine_posed_active_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_posed_active, ffi.Bool)>>('spine_posed_active_set_active');
  late final _spine_posed_active_set_active =
      _spine_posed_active_set_activePtr.asFunction<void Function(spine_posed_active, bool)>();

  spine_posed_data spine_posed_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_posed_data_create(
      name,
    );
  }

  late final _spine_posed_data_createPtr =
      _lookup<ffi.NativeFunction<spine_posed_data Function(ffi.Pointer<ffi.Char>)>>('spine_posed_data_create');
  late final _spine_posed_data_create =
      _spine_posed_data_createPtr.asFunction<spine_posed_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_posed_data_dispose(
    spine_posed_data self,
  ) {
    return _spine_posed_data_dispose(
      self,
    );
  }

  late final _spine_posed_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_posed_data)>>('spine_posed_data_dispose');
  late final _spine_posed_data_dispose = _spine_posed_data_disposePtr.asFunction<void Function(spine_posed_data)>();

  /// The constraint's name, which is unique across all constraints in the skeleton
  /// of the same type.
  ffi.Pointer<ffi.Char> spine_posed_data_get_name(
    spine_posed_data self,
  ) {
    return _spine_posed_data_get_name(
      self,
    );
  }

  late final _spine_posed_data_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_posed_data)>>('spine_posed_data_get_name');
  late final _spine_posed_data_get_name =
      _spine_posed_data_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_posed_data)>();

  /// When true, Skeleton::updateWorldTransform(Physics) only updates this
  /// constraint if the Skeleton::getSkin() contains this constraint.
  ///
  /// See Skin::getConstraints().
  bool spine_posed_data_get_skin_required(
    spine_posed_data self,
  ) {
    return _spine_posed_data_get_skin_required(
      self,
    );
  }

  late final _spine_posed_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_posed_data)>>('spine_posed_data_get_skin_required');
  late final _spine_posed_data_get_skin_required =
      _spine_posed_data_get_skin_requiredPtr.asFunction<bool Function(spine_posed_data)>();

  void spine_posed_data_set_skin_required(
    spine_posed_data self,
    bool skinRequired,
  ) {
    return _spine_posed_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_posed_data_set_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_posed_data, ffi.Bool)>>('spine_posed_data_set_skin_required');
  late final _spine_posed_data_set_skin_required =
      _spine_posed_data_set_skin_requiredPtr.asFunction<void Function(spine_posed_data, bool)>();

  spine_region_attachment spine_region_attachment_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_region_attachment_create(
      name,
    );
  }

  late final _spine_region_attachment_createPtr =
      _lookup<ffi.NativeFunction<spine_region_attachment Function(ffi.Pointer<ffi.Char>)>>(
          'spine_region_attachment_create');
  late final _spine_region_attachment_create =
      _spine_region_attachment_createPtr.asFunction<spine_region_attachment Function(ffi.Pointer<ffi.Char>)>();

  void spine_region_attachment_dispose(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_dispose(
      self,
    );
  }

  late final _spine_region_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment)>>('spine_region_attachment_dispose');
  late final _spine_region_attachment_dispose =
      _spine_region_attachment_disposePtr.asFunction<void Function(spine_region_attachment)>();

  spine_rtti spine_region_attachment_get_rtti(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_rtti(
      self,
    );
  }

  late final _spine_region_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_region_attachment)>>('spine_region_attachment_get_rtti');
  late final _spine_region_attachment_get_rtti =
      _spine_region_attachment_get_rttiPtr.asFunction<spine_rtti Function(spine_region_attachment)>();

  void spine_region_attachment_update_region(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_update_region(
      self,
    );
  }

  late final _spine_region_attachment_update_regionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment)>>('spine_region_attachment_update_region');
  late final _spine_region_attachment_update_region =
      _spine_region_attachment_update_regionPtr.asFunction<void Function(spine_region_attachment)>();

  /// Transforms the attachment's four vertices to world coordinates.
  ///
  /// @param slot The parent slot.
  /// @param worldVertices The output world vertices. Must have a length greater than or equal to offset + 8.
  /// @param offset The worldVertices index to begin writing values.
  /// @param stride The number of worldVertices entries between the value pairs written.
  void spine_region_attachment_compute_world_vertices_1(
    spine_region_attachment self,
    spine_slot slot,
    ffi.Pointer<ffi.Float> worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_region_attachment_compute_world_vertices_1(
      self,
      slot,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_region_attachment_compute_world_vertices_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_region_attachment, spine_slot, ffi.Pointer<ffi.Float>, ffi.Size,
              ffi.Size)>>('spine_region_attachment_compute_world_vertices_1');
  late final _spine_region_attachment_compute_world_vertices_1 = _spine_region_attachment_compute_world_vertices_1Ptr
      .asFunction<void Function(spine_region_attachment, spine_slot, ffi.Pointer<ffi.Float>, int, int)>();

  void spine_region_attachment_compute_world_vertices_2(
    spine_region_attachment self,
    spine_slot slot,
    spine_array_float worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_region_attachment_compute_world_vertices_2(
      self,
      slot,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_region_attachment_compute_world_vertices_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_region_attachment, spine_slot, spine_array_float, ffi.Size,
              ffi.Size)>>('spine_region_attachment_compute_world_vertices_2');
  late final _spine_region_attachment_compute_world_vertices_2 = _spine_region_attachment_compute_world_vertices_2Ptr
      .asFunction<void Function(spine_region_attachment, spine_slot, spine_array_float, int, int)>();

  double spine_region_attachment_get_x(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_x(
      self,
    );
  }

  late final _spine_region_attachment_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_x');
  late final _spine_region_attachment_get_x =
      _spine_region_attachment_get_xPtr.asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_x(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_x(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
          'spine_region_attachment_set_x');
  late final _spine_region_attachment_set_x =
      _spine_region_attachment_set_xPtr.asFunction<void Function(spine_region_attachment, double)>();

  double spine_region_attachment_get_y(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_y(
      self,
    );
  }

  late final _spine_region_attachment_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_y');
  late final _spine_region_attachment_get_y =
      _spine_region_attachment_get_yPtr.asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_y(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_y(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
          'spine_region_attachment_set_y');
  late final _spine_region_attachment_set_y =
      _spine_region_attachment_set_yPtr.asFunction<void Function(spine_region_attachment, double)>();

  double spine_region_attachment_get_rotation(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_rotation(
      self,
    );
  }

  late final _spine_region_attachment_get_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_rotation');
  late final _spine_region_attachment_get_rotation =
      _spine_region_attachment_get_rotationPtr.asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_rotation(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_rotation(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
          'spine_region_attachment_set_rotation');
  late final _spine_region_attachment_set_rotation =
      _spine_region_attachment_set_rotationPtr.asFunction<void Function(spine_region_attachment, double)>();

  double spine_region_attachment_get_scale_x(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_scale_x(
      self,
    );
  }

  late final _spine_region_attachment_get_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_scale_x');
  late final _spine_region_attachment_get_scale_x =
      _spine_region_attachment_get_scale_xPtr.asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_scale_x(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_scale_x(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
          'spine_region_attachment_set_scale_x');
  late final _spine_region_attachment_set_scale_x =
      _spine_region_attachment_set_scale_xPtr.asFunction<void Function(spine_region_attachment, double)>();

  double spine_region_attachment_get_scale_y(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_scale_y(
      self,
    );
  }

  late final _spine_region_attachment_get_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_scale_y');
  late final _spine_region_attachment_get_scale_y =
      _spine_region_attachment_get_scale_yPtr.asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_scale_y(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_scale_y(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
          'spine_region_attachment_set_scale_y');
  late final _spine_region_attachment_set_scale_y =
      _spine_region_attachment_set_scale_yPtr.asFunction<void Function(spine_region_attachment, double)>();

  double spine_region_attachment_get_width(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_width(
      self,
    );
  }

  late final _spine_region_attachment_get_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_width');
  late final _spine_region_attachment_get_width =
      _spine_region_attachment_get_widthPtr.asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_width(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_width(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
          'spine_region_attachment_set_width');
  late final _spine_region_attachment_set_width =
      _spine_region_attachment_set_widthPtr.asFunction<void Function(spine_region_attachment, double)>();

  double spine_region_attachment_get_height(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_height(
      self,
    );
  }

  late final _spine_region_attachment_get_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_height');
  late final _spine_region_attachment_get_height =
      _spine_region_attachment_get_heightPtr.asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_height(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_height(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
          'spine_region_attachment_set_height');
  late final _spine_region_attachment_set_height =
      _spine_region_attachment_set_heightPtr.asFunction<void Function(spine_region_attachment, double)>();

  spine_color spine_region_attachment_get_color(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_color(
      self,
    );
  }

  late final _spine_region_attachment_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_region_attachment)>>('spine_region_attachment_get_color');
  late final _spine_region_attachment_get_color =
      _spine_region_attachment_get_colorPtr.asFunction<spine_color Function(spine_region_attachment)>();

  ffi.Pointer<ffi.Char> spine_region_attachment_get_path(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_path(
      self,
    );
  }

  late final _spine_region_attachment_get_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_region_attachment)>>(
          'spine_region_attachment_get_path');
  late final _spine_region_attachment_get_path =
      _spine_region_attachment_get_pathPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_region_attachment)>();

  void spine_region_attachment_set_path(
    spine_region_attachment self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_region_attachment_set_path(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Pointer<ffi.Char>)>>(
          'spine_region_attachment_set_path');
  late final _spine_region_attachment_set_path =
      _spine_region_attachment_set_pathPtr.asFunction<void Function(spine_region_attachment, ffi.Pointer<ffi.Char>)>();

  spine_texture_region spine_region_attachment_get_region(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_region(
      self,
    );
  }

  late final _spine_region_attachment_get_regionPtr =
      _lookup<ffi.NativeFunction<spine_texture_region Function(spine_region_attachment)>>(
          'spine_region_attachment_get_region');
  late final _spine_region_attachment_get_region =
      _spine_region_attachment_get_regionPtr.asFunction<spine_texture_region Function(spine_region_attachment)>();

  void spine_region_attachment_set_region(
    spine_region_attachment self,
    spine_texture_region region,
  ) {
    return _spine_region_attachment_set_region(
      self,
      region,
    );
  }

  late final _spine_region_attachment_set_regionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, spine_texture_region)>>(
          'spine_region_attachment_set_region');
  late final _spine_region_attachment_set_region =
      _spine_region_attachment_set_regionPtr.asFunction<void Function(spine_region_attachment, spine_texture_region)>();

  spine_sequence spine_region_attachment_get_sequence(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_sequence(
      self,
    );
  }

  late final _spine_region_attachment_get_sequencePtr =
      _lookup<ffi.NativeFunction<spine_sequence Function(spine_region_attachment)>>(
          'spine_region_attachment_get_sequence');
  late final _spine_region_attachment_get_sequence =
      _spine_region_attachment_get_sequencePtr.asFunction<spine_sequence Function(spine_region_attachment)>();

  void spine_region_attachment_set_sequence(
    spine_region_attachment self,
    spine_sequence sequence,
  ) {
    return _spine_region_attachment_set_sequence(
      self,
      sequence,
    );
  }

  late final _spine_region_attachment_set_sequencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, spine_sequence)>>(
          'spine_region_attachment_set_sequence');
  late final _spine_region_attachment_set_sequence =
      _spine_region_attachment_set_sequencePtr.asFunction<void Function(spine_region_attachment, spine_sequence)>();

  spine_array_float spine_region_attachment_get_offset(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_offset(
      self,
    );
  }

  late final _spine_region_attachment_get_offsetPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_region_attachment)>>(
          'spine_region_attachment_get_offset');
  late final _spine_region_attachment_get_offset =
      _spine_region_attachment_get_offsetPtr.asFunction<spine_array_float Function(spine_region_attachment)>();

  spine_array_float spine_region_attachment_get_u_vs(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_u_vs(
      self,
    );
  }

  late final _spine_region_attachment_get_u_vsPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_region_attachment)>>(
          'spine_region_attachment_get_u_vs');
  late final _spine_region_attachment_get_u_vs =
      _spine_region_attachment_get_u_vsPtr.asFunction<spine_array_float Function(spine_region_attachment)>();

  spine_attachment spine_region_attachment_copy(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_copy(
      self,
    );
  }

  late final _spine_region_attachment_copyPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_region_attachment)>>('spine_region_attachment_copy');
  late final _spine_region_attachment_copy =
      _spine_region_attachment_copyPtr.asFunction<spine_attachment Function(spine_region_attachment)>();

  ffi.Pointer<ffi.Char> spine_region_attachment_get_name(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_name(
      self,
    );
  }

  late final _spine_region_attachment_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_region_attachment)>>(
          'spine_region_attachment_get_name');
  late final _spine_region_attachment_get_name =
      _spine_region_attachment_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_region_attachment)>();

  int spine_region_attachment_get_ref_count(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_region_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_region_attachment)>>('spine_region_attachment_get_ref_count');
  late final _spine_region_attachment_get_ref_count =
      _spine_region_attachment_get_ref_countPtr.asFunction<int Function(spine_region_attachment)>();

  void spine_region_attachment_reference(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_reference(
      self,
    );
  }

  late final _spine_region_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment)>>('spine_region_attachment_reference');
  late final _spine_region_attachment_reference =
      _spine_region_attachment_referencePtr.asFunction<void Function(spine_region_attachment)>();

  void spine_region_attachment_dereference(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_dereference(
      self,
    );
  }

  late final _spine_region_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment)>>('spine_region_attachment_dereference');
  late final _spine_region_attachment_dereference =
      _spine_region_attachment_dereferencePtr.asFunction<void Function(spine_region_attachment)>();

  spine_rtti spine_region_attachment_rtti() {
    return _spine_region_attachment_rtti();
  }

  late final _spine_region_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_region_attachment_rtti');
  late final _spine_region_attachment_rtti = _spine_region_attachment_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_render_command_dispose(
    spine_render_command self,
  ) {
    return _spine_render_command_dispose(
      self,
    );
  }

  late final _spine_render_command_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_render_command)>>('spine_render_command_dispose');
  late final _spine_render_command_dispose =
      _spine_render_command_disposePtr.asFunction<void Function(spine_render_command)>();

  ffi.Pointer<ffi.Float> spine_render_command_get_positions(
    spine_render_command self,
  ) {
    return _spine_render_command_get_positions(
      self,
    );
  }

  late final _spine_render_command_get_positionsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_render_command)>>(
          'spine_render_command_get_positions');
  late final _spine_render_command_get_positions =
      _spine_render_command_get_positionsPtr.asFunction<ffi.Pointer<ffi.Float> Function(spine_render_command)>();

  ffi.Pointer<ffi.Float> spine_render_command_get_uvs(
    spine_render_command self,
  ) {
    return _spine_render_command_get_uvs(
      self,
    );
  }

  late final _spine_render_command_get_uvsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_render_command)>>(
          'spine_render_command_get_uvs');
  late final _spine_render_command_get_uvs =
      _spine_render_command_get_uvsPtr.asFunction<ffi.Pointer<ffi.Float> Function(spine_render_command)>();

  ffi.Pointer<ffi.Uint32> spine_render_command_get_colors(
    spine_render_command self,
  ) {
    return _spine_render_command_get_colors(
      self,
    );
  }

  late final _spine_render_command_get_colorsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Uint32> Function(spine_render_command)>>(
          'spine_render_command_get_colors');
  late final _spine_render_command_get_colors =
      _spine_render_command_get_colorsPtr.asFunction<ffi.Pointer<ffi.Uint32> Function(spine_render_command)>();

  ffi.Pointer<ffi.Uint32> spine_render_command_get_dark_colors(
    spine_render_command self,
  ) {
    return _spine_render_command_get_dark_colors(
      self,
    );
  }

  late final _spine_render_command_get_dark_colorsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Uint32> Function(spine_render_command)>>(
          'spine_render_command_get_dark_colors');
  late final _spine_render_command_get_dark_colors =
      _spine_render_command_get_dark_colorsPtr.asFunction<ffi.Pointer<ffi.Uint32> Function(spine_render_command)>();

  int spine_render_command_get_num_vertices(
    spine_render_command self,
  ) {
    return _spine_render_command_get_num_vertices(
      self,
    );
  }

  late final _spine_render_command_get_num_verticesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_render_command)>>('spine_render_command_get_num_vertices');
  late final _spine_render_command_get_num_vertices =
      _spine_render_command_get_num_verticesPtr.asFunction<int Function(spine_render_command)>();

  ffi.Pointer<ffi.Uint16> spine_render_command_get_indices(
    spine_render_command self,
  ) {
    return _spine_render_command_get_indices(
      self,
    );
  }

  late final _spine_render_command_get_indicesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Uint16> Function(spine_render_command)>>(
          'spine_render_command_get_indices');
  late final _spine_render_command_get_indices =
      _spine_render_command_get_indicesPtr.asFunction<ffi.Pointer<ffi.Uint16> Function(spine_render_command)>();

  int spine_render_command_get_num_indices(
    spine_render_command self,
  ) {
    return _spine_render_command_get_num_indices(
      self,
    );
  }

  late final _spine_render_command_get_num_indicesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_render_command)>>('spine_render_command_get_num_indices');
  late final _spine_render_command_get_num_indices =
      _spine_render_command_get_num_indicesPtr.asFunction<int Function(spine_render_command)>();

  int spine_render_command_get_blend_mode(
    spine_render_command self,
  ) {
    return _spine_render_command_get_blend_mode(
      self,
    );
  }

  late final _spine_render_command_get_blend_modePtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_render_command)>>('spine_render_command_get_blend_mode');
  late final _spine_render_command_get_blend_mode =
      _spine_render_command_get_blend_modePtr.asFunction<int Function(spine_render_command)>();

  ffi.Pointer<ffi.Void> spine_render_command_get_texture(
    spine_render_command self,
  ) {
    return _spine_render_command_get_texture(
      self,
    );
  }

  late final _spine_render_command_get_texturePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(spine_render_command)>>(
          'spine_render_command_get_texture');
  late final _spine_render_command_get_texture =
      _spine_render_command_get_texturePtr.asFunction<ffi.Pointer<ffi.Void> Function(spine_render_command)>();

  spine_render_command spine_render_command_get_next(
    spine_render_command self,
  ) {
    return _spine_render_command_get_next(
      self,
    );
  }

  late final _spine_render_command_get_nextPtr =
      _lookup<ffi.NativeFunction<spine_render_command Function(spine_render_command)>>('spine_render_command_get_next');
  late final _spine_render_command_get_next =
      _spine_render_command_get_nextPtr.asFunction<spine_render_command Function(spine_render_command)>();

  spine_rgb2_timeline spine_rgb2_timeline_create(
    int frameCount,
    int bezierCount,
    int slotIndex,
  ) {
    return _spine_rgb2_timeline_create(
      frameCount,
      bezierCount,
      slotIndex,
    );
  }

  late final _spine_rgb2_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_rgb2_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_rgb2_timeline_create');
  late final _spine_rgb2_timeline_create =
      _spine_rgb2_timeline_createPtr.asFunction<spine_rgb2_timeline Function(int, int, int)>();

  void spine_rgb2_timeline_dispose(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_dispose(
      self,
    );
  }

  late final _spine_rgb2_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgb2_timeline)>>('spine_rgb2_timeline_dispose');
  late final _spine_rgb2_timeline_dispose =
      _spine_rgb2_timeline_disposePtr.asFunction<void Function(spine_rgb2_timeline)>();

  spine_rtti spine_rgb2_timeline_get_rtti(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_rtti(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_rgb2_timeline)>>('spine_rgb2_timeline_get_rtti');
  late final _spine_rgb2_timeline_get_rtti =
      _spine_rgb2_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_rgb2_timeline)>();

  /// Sets the time, light color, and dark color for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_rgb2_timeline_set_frame(
    spine_rgb2_timeline self,
    int frame,
    double time,
    double r,
    double g,
    double b,
    double r2,
    double g2,
    double b2,
  ) {
    return _spine_rgb2_timeline_set_frame(
      self,
      frame,
      time,
      r,
      g,
      b,
      r2,
      g2,
      b2,
    );
  }

  late final _spine_rgb2_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rgb2_timeline, ffi.Int, ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_rgb2_timeline_set_frame');
  late final _spine_rgb2_timeline_set_frame = _spine_rgb2_timeline_set_framePtr
      .asFunction<void Function(spine_rgb2_timeline, int, double, double, double, double, double, double, double)>();

  void spine_rgb2_timeline_apply(
    spine_rgb2_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_rgb2_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_rgb2_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rgb2_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_rgb2_timeline_apply');
  late final _spine_rgb2_timeline_apply = _spine_rgb2_timeline_applyPtr.asFunction<
      void Function(spine_rgb2_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_rgb2_timeline_get_slot_index(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_rgb2_timeline)>>('spine_rgb2_timeline_get_slot_index');
  late final _spine_rgb2_timeline_get_slot_index =
      _spine_rgb2_timeline_get_slot_indexPtr.asFunction<int Function(spine_rgb2_timeline)>();

  void spine_rgb2_timeline_set_slot_index(
    spine_rgb2_timeline self,
    int inValue,
  ) {
    return _spine_rgb2_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_rgb2_timeline_set_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgb2_timeline, ffi.Int)>>(
          'spine_rgb2_timeline_set_slot_index');
  late final _spine_rgb2_timeline_set_slot_index =
      _spine_rgb2_timeline_set_slot_indexPtr.asFunction<void Function(spine_rgb2_timeline, int)>();

  void spine_rgb2_timeline_set_linear(
    spine_rgb2_timeline self,
    int frame,
  ) {
    return _spine_rgb2_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_rgb2_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgb2_timeline, ffi.Size)>>('spine_rgb2_timeline_set_linear');
  late final _spine_rgb2_timeline_set_linear =
      _spine_rgb2_timeline_set_linearPtr.asFunction<void Function(spine_rgb2_timeline, int)>();

  void spine_rgb2_timeline_set_stepped(
    spine_rgb2_timeline self,
    int frame,
  ) {
    return _spine_rgb2_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_rgb2_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgb2_timeline, ffi.Size)>>('spine_rgb2_timeline_set_stepped');
  late final _spine_rgb2_timeline_set_stepped =
      _spine_rgb2_timeline_set_steppedPtr.asFunction<void Function(spine_rgb2_timeline, int)>();

  void spine_rgb2_timeline_set_bezier(
    spine_rgb2_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_rgb2_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_rgb2_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rgb2_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_rgb2_timeline_set_bezier');
  late final _spine_rgb2_timeline_set_bezier = _spine_rgb2_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_rgb2_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_rgb2_timeline_get_bezier_value(
    spine_rgb2_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_rgb2_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_rgb2_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rgb2_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_rgb2_timeline_get_bezier_value');
  late final _spine_rgb2_timeline_get_bezier_value = _spine_rgb2_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_rgb2_timeline, double, int, int, int)>();

  spine_array_float spine_rgb2_timeline_get_curves(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_curves(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_rgb2_timeline)>>('spine_rgb2_timeline_get_curves');
  late final _spine_rgb2_timeline_get_curves =
      _spine_rgb2_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_rgb2_timeline)>();

  int spine_rgb2_timeline_get_frame_entries(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgb2_timeline)>>('spine_rgb2_timeline_get_frame_entries');
  late final _spine_rgb2_timeline_get_frame_entries =
      _spine_rgb2_timeline_get_frame_entriesPtr.asFunction<int Function(spine_rgb2_timeline)>();

  int spine_rgb2_timeline_get_frame_count(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgb2_timeline)>>('spine_rgb2_timeline_get_frame_count');
  late final _spine_rgb2_timeline_get_frame_count =
      _spine_rgb2_timeline_get_frame_countPtr.asFunction<int Function(spine_rgb2_timeline)>();

  spine_array_float spine_rgb2_timeline_get_frames(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_frames(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_rgb2_timeline)>>('spine_rgb2_timeline_get_frames');
  late final _spine_rgb2_timeline_get_frames =
      _spine_rgb2_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_rgb2_timeline)>();

  double spine_rgb2_timeline_get_duration(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_duration(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rgb2_timeline)>>('spine_rgb2_timeline_get_duration');
  late final _spine_rgb2_timeline_get_duration =
      _spine_rgb2_timeline_get_durationPtr.asFunction<double Function(spine_rgb2_timeline)>();

  spine_array_property_id spine_rgb2_timeline_get_property_ids(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_rgb2_timeline)>>(
          'spine_rgb2_timeline_get_property_ids');
  late final _spine_rgb2_timeline_get_property_ids =
      _spine_rgb2_timeline_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_rgb2_timeline)>();

  spine_rtti spine_rgb2_timeline_rtti() {
    return _spine_rgb2_timeline_rtti();
  }

  late final _spine_rgb2_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_rgb2_timeline_rtti');
  late final _spine_rgb2_timeline_rtti = _spine_rgb2_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_rgba2_timeline spine_rgba2_timeline_create(
    int frameCount,
    int bezierCount,
    int slotIndex,
  ) {
    return _spine_rgba2_timeline_create(
      frameCount,
      bezierCount,
      slotIndex,
    );
  }

  late final _spine_rgba2_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_rgba2_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_rgba2_timeline_create');
  late final _spine_rgba2_timeline_create =
      _spine_rgba2_timeline_createPtr.asFunction<spine_rgba2_timeline Function(int, int, int)>();

  void spine_rgba2_timeline_dispose(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_dispose(
      self,
    );
  }

  late final _spine_rgba2_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgba2_timeline)>>('spine_rgba2_timeline_dispose');
  late final _spine_rgba2_timeline_dispose =
      _spine_rgba2_timeline_disposePtr.asFunction<void Function(spine_rgba2_timeline)>();

  spine_rtti spine_rgba2_timeline_get_rtti(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_rtti(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_rgba2_timeline)>>('spine_rgba2_timeline_get_rtti');
  late final _spine_rgba2_timeline_get_rtti =
      _spine_rgba2_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_rgba2_timeline)>();

  /// Sets the time, light color, and dark color for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_rgba2_timeline_set_frame(
    spine_rgba2_timeline self,
    int frame,
    double time,
    double r,
    double g,
    double b,
    double a,
    double r2,
    double g2,
    double b2,
  ) {
    return _spine_rgba2_timeline_set_frame(
      self,
      frame,
      time,
      r,
      g,
      b,
      a,
      r2,
      g2,
      b2,
    );
  }

  late final _spine_rgba2_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rgba2_timeline, ffi.Int, ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float)>>('spine_rgba2_timeline_set_frame');
  late final _spine_rgba2_timeline_set_frame = _spine_rgba2_timeline_set_framePtr.asFunction<
      void Function(spine_rgba2_timeline, int, double, double, double, double, double, double, double, double)>();

  void spine_rgba2_timeline_apply(
    spine_rgba2_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_rgba2_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_rgba2_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rgba2_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_rgba2_timeline_apply');
  late final _spine_rgba2_timeline_apply = _spine_rgba2_timeline_applyPtr.asFunction<
      void Function(spine_rgba2_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_rgba2_timeline_get_slot_index(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_rgba2_timeline)>>('spine_rgba2_timeline_get_slot_index');
  late final _spine_rgba2_timeline_get_slot_index =
      _spine_rgba2_timeline_get_slot_indexPtr.asFunction<int Function(spine_rgba2_timeline)>();

  void spine_rgba2_timeline_set_slot_index(
    spine_rgba2_timeline self,
    int inValue,
  ) {
    return _spine_rgba2_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_rgba2_timeline_set_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgba2_timeline, ffi.Int)>>(
          'spine_rgba2_timeline_set_slot_index');
  late final _spine_rgba2_timeline_set_slot_index =
      _spine_rgba2_timeline_set_slot_indexPtr.asFunction<void Function(spine_rgba2_timeline, int)>();

  void spine_rgba2_timeline_set_linear(
    spine_rgba2_timeline self,
    int frame,
  ) {
    return _spine_rgba2_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_rgba2_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgba2_timeline, ffi.Size)>>('spine_rgba2_timeline_set_linear');
  late final _spine_rgba2_timeline_set_linear =
      _spine_rgba2_timeline_set_linearPtr.asFunction<void Function(spine_rgba2_timeline, int)>();

  void spine_rgba2_timeline_set_stepped(
    spine_rgba2_timeline self,
    int frame,
  ) {
    return _spine_rgba2_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_rgba2_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgba2_timeline, ffi.Size)>>(
          'spine_rgba2_timeline_set_stepped');
  late final _spine_rgba2_timeline_set_stepped =
      _spine_rgba2_timeline_set_steppedPtr.asFunction<void Function(spine_rgba2_timeline, int)>();

  void spine_rgba2_timeline_set_bezier(
    spine_rgba2_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_rgba2_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_rgba2_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rgba2_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_rgba2_timeline_set_bezier');
  late final _spine_rgba2_timeline_set_bezier = _spine_rgba2_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_rgba2_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_rgba2_timeline_get_bezier_value(
    spine_rgba2_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_rgba2_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_rgba2_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rgba2_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_rgba2_timeline_get_bezier_value');
  late final _spine_rgba2_timeline_get_bezier_value = _spine_rgba2_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_rgba2_timeline, double, int, int, int)>();

  spine_array_float spine_rgba2_timeline_get_curves(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_curves(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_rgba2_timeline)>>('spine_rgba2_timeline_get_curves');
  late final _spine_rgba2_timeline_get_curves =
      _spine_rgba2_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_rgba2_timeline)>();

  int spine_rgba2_timeline_get_frame_entries(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgba2_timeline)>>('spine_rgba2_timeline_get_frame_entries');
  late final _spine_rgba2_timeline_get_frame_entries =
      _spine_rgba2_timeline_get_frame_entriesPtr.asFunction<int Function(spine_rgba2_timeline)>();

  int spine_rgba2_timeline_get_frame_count(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgba2_timeline)>>('spine_rgba2_timeline_get_frame_count');
  late final _spine_rgba2_timeline_get_frame_count =
      _spine_rgba2_timeline_get_frame_countPtr.asFunction<int Function(spine_rgba2_timeline)>();

  spine_array_float spine_rgba2_timeline_get_frames(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_frames(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_rgba2_timeline)>>('spine_rgba2_timeline_get_frames');
  late final _spine_rgba2_timeline_get_frames =
      _spine_rgba2_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_rgba2_timeline)>();

  double spine_rgba2_timeline_get_duration(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_duration(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rgba2_timeline)>>('spine_rgba2_timeline_get_duration');
  late final _spine_rgba2_timeline_get_duration =
      _spine_rgba2_timeline_get_durationPtr.asFunction<double Function(spine_rgba2_timeline)>();

  spine_array_property_id spine_rgba2_timeline_get_property_ids(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_rgba2_timeline)>>(
          'spine_rgba2_timeline_get_property_ids');
  late final _spine_rgba2_timeline_get_property_ids =
      _spine_rgba2_timeline_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_rgba2_timeline)>();

  spine_rtti spine_rgba2_timeline_rtti() {
    return _spine_rgba2_timeline_rtti();
  }

  late final _spine_rgba2_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_rgba2_timeline_rtti');
  late final _spine_rgba2_timeline_rtti = _spine_rgba2_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_rgba_timeline spine_rgba_timeline_create(
    int frameCount,
    int bezierCount,
    int slotIndex,
  ) {
    return _spine_rgba_timeline_create(
      frameCount,
      bezierCount,
      slotIndex,
    );
  }

  late final _spine_rgba_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_rgba_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_rgba_timeline_create');
  late final _spine_rgba_timeline_create =
      _spine_rgba_timeline_createPtr.asFunction<spine_rgba_timeline Function(int, int, int)>();

  void spine_rgba_timeline_dispose(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_dispose(
      self,
    );
  }

  late final _spine_rgba_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgba_timeline)>>('spine_rgba_timeline_dispose');
  late final _spine_rgba_timeline_dispose =
      _spine_rgba_timeline_disposePtr.asFunction<void Function(spine_rgba_timeline)>();

  spine_rtti spine_rgba_timeline_get_rtti(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_rtti(
      self,
    );
  }

  late final _spine_rgba_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_rgba_timeline)>>('spine_rgba_timeline_get_rtti');
  late final _spine_rgba_timeline_get_rtti =
      _spine_rgba_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_rgba_timeline)>();

  /// Sets the time and color for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_rgba_timeline_set_frame(
    spine_rgba_timeline self,
    int frame,
    double time,
    double r,
    double g,
    double b,
    double a,
  ) {
    return _spine_rgba_timeline_set_frame(
      self,
      frame,
      time,
      r,
      g,
      b,
      a,
    );
  }

  late final _spine_rgba_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rgba_timeline, ffi.Int, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_rgba_timeline_set_frame');
  late final _spine_rgba_timeline_set_frame = _spine_rgba_timeline_set_framePtr
      .asFunction<void Function(spine_rgba_timeline, int, double, double, double, double, double)>();

  void spine_rgba_timeline_apply(
    spine_rgba_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_rgba_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_rgba_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rgba_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_rgba_timeline_apply');
  late final _spine_rgba_timeline_apply = _spine_rgba_timeline_applyPtr.asFunction<
      void Function(spine_rgba_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_rgba_timeline_get_slot_index(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_rgba_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_rgba_timeline)>>('spine_rgba_timeline_get_slot_index');
  late final _spine_rgba_timeline_get_slot_index =
      _spine_rgba_timeline_get_slot_indexPtr.asFunction<int Function(spine_rgba_timeline)>();

  void spine_rgba_timeline_set_slot_index(
    spine_rgba_timeline self,
    int inValue,
  ) {
    return _spine_rgba_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_rgba_timeline_set_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgba_timeline, ffi.Int)>>(
          'spine_rgba_timeline_set_slot_index');
  late final _spine_rgba_timeline_set_slot_index =
      _spine_rgba_timeline_set_slot_indexPtr.asFunction<void Function(spine_rgba_timeline, int)>();

  void spine_rgba_timeline_set_linear(
    spine_rgba_timeline self,
    int frame,
  ) {
    return _spine_rgba_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_rgba_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgba_timeline, ffi.Size)>>('spine_rgba_timeline_set_linear');
  late final _spine_rgba_timeline_set_linear =
      _spine_rgba_timeline_set_linearPtr.asFunction<void Function(spine_rgba_timeline, int)>();

  void spine_rgba_timeline_set_stepped(
    spine_rgba_timeline self,
    int frame,
  ) {
    return _spine_rgba_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_rgba_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgba_timeline, ffi.Size)>>('spine_rgba_timeline_set_stepped');
  late final _spine_rgba_timeline_set_stepped =
      _spine_rgba_timeline_set_steppedPtr.asFunction<void Function(spine_rgba_timeline, int)>();

  void spine_rgba_timeline_set_bezier(
    spine_rgba_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_rgba_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_rgba_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rgba_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_rgba_timeline_set_bezier');
  late final _spine_rgba_timeline_set_bezier = _spine_rgba_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_rgba_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_rgba_timeline_get_bezier_value(
    spine_rgba_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_rgba_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_rgba_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rgba_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_rgba_timeline_get_bezier_value');
  late final _spine_rgba_timeline_get_bezier_value = _spine_rgba_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_rgba_timeline, double, int, int, int)>();

  spine_array_float spine_rgba_timeline_get_curves(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_curves(
      self,
    );
  }

  late final _spine_rgba_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_rgba_timeline)>>('spine_rgba_timeline_get_curves');
  late final _spine_rgba_timeline_get_curves =
      _spine_rgba_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_rgba_timeline)>();

  int spine_rgba_timeline_get_frame_entries(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_rgba_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgba_timeline)>>('spine_rgba_timeline_get_frame_entries');
  late final _spine_rgba_timeline_get_frame_entries =
      _spine_rgba_timeline_get_frame_entriesPtr.asFunction<int Function(spine_rgba_timeline)>();

  int spine_rgba_timeline_get_frame_count(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_rgba_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgba_timeline)>>('spine_rgba_timeline_get_frame_count');
  late final _spine_rgba_timeline_get_frame_count =
      _spine_rgba_timeline_get_frame_countPtr.asFunction<int Function(spine_rgba_timeline)>();

  spine_array_float spine_rgba_timeline_get_frames(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_frames(
      self,
    );
  }

  late final _spine_rgba_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_rgba_timeline)>>('spine_rgba_timeline_get_frames');
  late final _spine_rgba_timeline_get_frames =
      _spine_rgba_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_rgba_timeline)>();

  double spine_rgba_timeline_get_duration(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_duration(
      self,
    );
  }

  late final _spine_rgba_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rgba_timeline)>>('spine_rgba_timeline_get_duration');
  late final _spine_rgba_timeline_get_duration =
      _spine_rgba_timeline_get_durationPtr.asFunction<double Function(spine_rgba_timeline)>();

  spine_array_property_id spine_rgba_timeline_get_property_ids(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_rgba_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_rgba_timeline)>>(
          'spine_rgba_timeline_get_property_ids');
  late final _spine_rgba_timeline_get_property_ids =
      _spine_rgba_timeline_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_rgba_timeline)>();

  spine_rtti spine_rgba_timeline_rtti() {
    return _spine_rgba_timeline_rtti();
  }

  late final _spine_rgba_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_rgba_timeline_rtti');
  late final _spine_rgba_timeline_rtti = _spine_rgba_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_rgb_timeline spine_rgb_timeline_create(
    int frameCount,
    int bezierCount,
    int slotIndex,
  ) {
    return _spine_rgb_timeline_create(
      frameCount,
      bezierCount,
      slotIndex,
    );
  }

  late final _spine_rgb_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_rgb_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_rgb_timeline_create');
  late final _spine_rgb_timeline_create =
      _spine_rgb_timeline_createPtr.asFunction<spine_rgb_timeline Function(int, int, int)>();

  void spine_rgb_timeline_dispose(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_dispose(
      self,
    );
  }

  late final _spine_rgb_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgb_timeline)>>('spine_rgb_timeline_dispose');
  late final _spine_rgb_timeline_dispose =
      _spine_rgb_timeline_disposePtr.asFunction<void Function(spine_rgb_timeline)>();

  spine_rtti spine_rgb_timeline_get_rtti(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_rtti(
      self,
    );
  }

  late final _spine_rgb_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_rgb_timeline)>>('spine_rgb_timeline_get_rtti');
  late final _spine_rgb_timeline_get_rtti =
      _spine_rgb_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_rgb_timeline)>();

  /// Sets the time and color for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_rgb_timeline_set_frame(
    spine_rgb_timeline self,
    int frame,
    double time,
    double r,
    double g,
    double b,
  ) {
    return _spine_rgb_timeline_set_frame(
      self,
      frame,
      time,
      r,
      g,
      b,
    );
  }

  late final _spine_rgb_timeline_set_framePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_rgb_timeline, ffi.Int, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
      'spine_rgb_timeline_set_frame');
  late final _spine_rgb_timeline_set_frame = _spine_rgb_timeline_set_framePtr
      .asFunction<void Function(spine_rgb_timeline, int, double, double, double, double)>();

  void spine_rgb_timeline_apply(
    spine_rgb_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_rgb_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_rgb_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rgb_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_rgb_timeline_apply');
  late final _spine_rgb_timeline_apply = _spine_rgb_timeline_applyPtr.asFunction<
      void Function(spine_rgb_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_rgb_timeline_get_slot_index(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_rgb_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_rgb_timeline)>>('spine_rgb_timeline_get_slot_index');
  late final _spine_rgb_timeline_get_slot_index =
      _spine_rgb_timeline_get_slot_indexPtr.asFunction<int Function(spine_rgb_timeline)>();

  void spine_rgb_timeline_set_slot_index(
    spine_rgb_timeline self,
    int inValue,
  ) {
    return _spine_rgb_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_rgb_timeline_set_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgb_timeline, ffi.Int)>>('spine_rgb_timeline_set_slot_index');
  late final _spine_rgb_timeline_set_slot_index =
      _spine_rgb_timeline_set_slot_indexPtr.asFunction<void Function(spine_rgb_timeline, int)>();

  void spine_rgb_timeline_set_linear(
    spine_rgb_timeline self,
    int frame,
  ) {
    return _spine_rgb_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_rgb_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgb_timeline, ffi.Size)>>('spine_rgb_timeline_set_linear');
  late final _spine_rgb_timeline_set_linear =
      _spine_rgb_timeline_set_linearPtr.asFunction<void Function(spine_rgb_timeline, int)>();

  void spine_rgb_timeline_set_stepped(
    spine_rgb_timeline self,
    int frame,
  ) {
    return _spine_rgb_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_rgb_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgb_timeline, ffi.Size)>>('spine_rgb_timeline_set_stepped');
  late final _spine_rgb_timeline_set_stepped =
      _spine_rgb_timeline_set_steppedPtr.asFunction<void Function(spine_rgb_timeline, int)>();

  void spine_rgb_timeline_set_bezier(
    spine_rgb_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_rgb_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_rgb_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rgb_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_rgb_timeline_set_bezier');
  late final _spine_rgb_timeline_set_bezier = _spine_rgb_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_rgb_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_rgb_timeline_get_bezier_value(
    spine_rgb_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_rgb_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_rgb_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rgb_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_rgb_timeline_get_bezier_value');
  late final _spine_rgb_timeline_get_bezier_value =
      _spine_rgb_timeline_get_bezier_valuePtr.asFunction<double Function(spine_rgb_timeline, double, int, int, int)>();

  spine_array_float spine_rgb_timeline_get_curves(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_curves(
      self,
    );
  }

  late final _spine_rgb_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_rgb_timeline)>>('spine_rgb_timeline_get_curves');
  late final _spine_rgb_timeline_get_curves =
      _spine_rgb_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_rgb_timeline)>();

  int spine_rgb_timeline_get_frame_entries(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_rgb_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgb_timeline)>>('spine_rgb_timeline_get_frame_entries');
  late final _spine_rgb_timeline_get_frame_entries =
      _spine_rgb_timeline_get_frame_entriesPtr.asFunction<int Function(spine_rgb_timeline)>();

  int spine_rgb_timeline_get_frame_count(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_rgb_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgb_timeline)>>('spine_rgb_timeline_get_frame_count');
  late final _spine_rgb_timeline_get_frame_count =
      _spine_rgb_timeline_get_frame_countPtr.asFunction<int Function(spine_rgb_timeline)>();

  spine_array_float spine_rgb_timeline_get_frames(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_frames(
      self,
    );
  }

  late final _spine_rgb_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_rgb_timeline)>>('spine_rgb_timeline_get_frames');
  late final _spine_rgb_timeline_get_frames =
      _spine_rgb_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_rgb_timeline)>();

  double spine_rgb_timeline_get_duration(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_duration(
      self,
    );
  }

  late final _spine_rgb_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rgb_timeline)>>('spine_rgb_timeline_get_duration');
  late final _spine_rgb_timeline_get_duration =
      _spine_rgb_timeline_get_durationPtr.asFunction<double Function(spine_rgb_timeline)>();

  spine_array_property_id spine_rgb_timeline_get_property_ids(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_rgb_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_rgb_timeline)>>(
          'spine_rgb_timeline_get_property_ids');
  late final _spine_rgb_timeline_get_property_ids =
      _spine_rgb_timeline_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_rgb_timeline)>();

  spine_rtti spine_rgb_timeline_rtti() {
    return _spine_rgb_timeline_rtti();
  }

  late final _spine_rgb_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_rgb_timeline_rtti');
  late final _spine_rgb_timeline_rtti = _spine_rgb_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_rotate_timeline spine_rotate_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_rotate_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_rotate_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_rotate_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_rotate_timeline_create');
  late final _spine_rotate_timeline_create =
      _spine_rotate_timeline_createPtr.asFunction<spine_rotate_timeline Function(int, int, int)>();

  void spine_rotate_timeline_dispose(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_dispose(
      self,
    );
  }

  late final _spine_rotate_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rotate_timeline)>>('spine_rotate_timeline_dispose');
  late final _spine_rotate_timeline_dispose =
      _spine_rotate_timeline_disposePtr.asFunction<void Function(spine_rotate_timeline)>();

  spine_rtti spine_rotate_timeline_get_rtti(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_rtti(
      self,
    );
  }

  late final _spine_rotate_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_rotate_timeline)>>('spine_rotate_timeline_get_rtti');
  late final _spine_rotate_timeline_get_rtti =
      _spine_rotate_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_rotate_timeline)>();

  void spine_rotate_timeline_apply(
    spine_rotate_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_rotate_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_rotate_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rotate_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_rotate_timeline_apply');
  late final _spine_rotate_timeline_apply = _spine_rotate_timeline_applyPtr.asFunction<
      void Function(
          spine_rotate_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_rotate_timeline_get_bone_index(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_rotate_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_rotate_timeline)>>('spine_rotate_timeline_get_bone_index');
  late final _spine_rotate_timeline_get_bone_index =
      _spine_rotate_timeline_get_bone_indexPtr.asFunction<int Function(spine_rotate_timeline)>();

  void spine_rotate_timeline_set_bone_index(
    spine_rotate_timeline self,
    int inValue,
  ) {
    return _spine_rotate_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_rotate_timeline_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rotate_timeline, ffi.Int)>>(
          'spine_rotate_timeline_set_bone_index');
  late final _spine_rotate_timeline_set_bone_index =
      _spine_rotate_timeline_set_bone_indexPtr.asFunction<void Function(spine_rotate_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_rotate_timeline_set_frame(
    spine_rotate_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_rotate_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_rotate_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rotate_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_rotate_timeline_set_frame');
  late final _spine_rotate_timeline_set_frame =
      _spine_rotate_timeline_set_framePtr.asFunction<void Function(spine_rotate_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_rotate_timeline_get_curve_value(
    spine_rotate_timeline self,
    double time,
  ) {
    return _spine_rotate_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_rotate_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rotate_timeline, ffi.Float)>>(
          'spine_rotate_timeline_get_curve_value');
  late final _spine_rotate_timeline_get_curve_value =
      _spine_rotate_timeline_get_curve_valuePtr.asFunction<double Function(spine_rotate_timeline, double)>();

  double spine_rotate_timeline_get_relative_value(
    spine_rotate_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_rotate_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_rotate_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_rotate_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_rotate_timeline_get_relative_value');
  late final _spine_rotate_timeline_get_relative_value = _spine_rotate_timeline_get_relative_valuePtr
      .asFunction<double Function(spine_rotate_timeline, double, double, int, double, double)>();

  double spine_rotate_timeline_get_absolute_value_1(
    spine_rotate_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_rotate_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_rotate_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_rotate_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_rotate_timeline_get_absolute_value_1');
  late final _spine_rotate_timeline_get_absolute_value_1 = _spine_rotate_timeline_get_absolute_value_1Ptr
      .asFunction<double Function(spine_rotate_timeline, double, double, int, double, double)>();

  double spine_rotate_timeline_get_absolute_value_2(
    spine_rotate_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_rotate_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_rotate_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_rotate_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_rotate_timeline_get_absolute_value_2');
  late final _spine_rotate_timeline_get_absolute_value_2 = _spine_rotate_timeline_get_absolute_value_2Ptr
      .asFunction<double Function(spine_rotate_timeline, double, double, int, double, double, double)>();

  double spine_rotate_timeline_get_scale_value(
    spine_rotate_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_rotate_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_rotate_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_rotate_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_rotate_timeline_get_scale_value');
  late final _spine_rotate_timeline_get_scale_value = _spine_rotate_timeline_get_scale_valuePtr
      .asFunction<double Function(spine_rotate_timeline, double, double, int, int, double, double)>();

  void spine_rotate_timeline_set_linear(
    spine_rotate_timeline self,
    int frame,
  ) {
    return _spine_rotate_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_rotate_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rotate_timeline, ffi.Size)>>(
          'spine_rotate_timeline_set_linear');
  late final _spine_rotate_timeline_set_linear =
      _spine_rotate_timeline_set_linearPtr.asFunction<void Function(spine_rotate_timeline, int)>();

  void spine_rotate_timeline_set_stepped(
    spine_rotate_timeline self,
    int frame,
  ) {
    return _spine_rotate_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_rotate_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rotate_timeline, ffi.Size)>>(
          'spine_rotate_timeline_set_stepped');
  late final _spine_rotate_timeline_set_stepped =
      _spine_rotate_timeline_set_steppedPtr.asFunction<void Function(spine_rotate_timeline, int)>();

  void spine_rotate_timeline_set_bezier(
    spine_rotate_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_rotate_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_rotate_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rotate_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_rotate_timeline_set_bezier');
  late final _spine_rotate_timeline_set_bezier = _spine_rotate_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_rotate_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_rotate_timeline_get_bezier_value(
    spine_rotate_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_rotate_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_rotate_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rotate_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_rotate_timeline_get_bezier_value');
  late final _spine_rotate_timeline_get_bezier_value = _spine_rotate_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_rotate_timeline, double, int, int, int)>();

  spine_array_float spine_rotate_timeline_get_curves(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_curves(
      self,
    );
  }

  late final _spine_rotate_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_get_curves');
  late final _spine_rotate_timeline_get_curves =
      _spine_rotate_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_rotate_timeline)>();

  int spine_rotate_timeline_get_frame_entries(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_rotate_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rotate_timeline)>>('spine_rotate_timeline_get_frame_entries');
  late final _spine_rotate_timeline_get_frame_entries =
      _spine_rotate_timeline_get_frame_entriesPtr.asFunction<int Function(spine_rotate_timeline)>();

  int spine_rotate_timeline_get_frame_count(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_rotate_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rotate_timeline)>>('spine_rotate_timeline_get_frame_count');
  late final _spine_rotate_timeline_get_frame_count =
      _spine_rotate_timeline_get_frame_countPtr.asFunction<int Function(spine_rotate_timeline)>();

  spine_array_float spine_rotate_timeline_get_frames(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_frames(
      self,
    );
  }

  late final _spine_rotate_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_get_frames');
  late final _spine_rotate_timeline_get_frames =
      _spine_rotate_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_rotate_timeline)>();

  double spine_rotate_timeline_get_duration(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_duration(
      self,
    );
  }

  late final _spine_rotate_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rotate_timeline)>>('spine_rotate_timeline_get_duration');
  late final _spine_rotate_timeline_get_duration =
      _spine_rotate_timeline_get_durationPtr.asFunction<double Function(spine_rotate_timeline)>();

  spine_array_property_id spine_rotate_timeline_get_property_ids(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_rotate_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_get_property_ids');
  late final _spine_rotate_timeline_get_property_ids =
      _spine_rotate_timeline_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_rotate_timeline)>();

  spine_rtti spine_rotate_timeline_rtti() {
    return _spine_rotate_timeline_rtti();
  }

  late final _spine_rotate_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_rotate_timeline_rtti');
  late final _spine_rotate_timeline_rtti = _spine_rotate_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_rtti_dispose(
    spine_rtti self,
  ) {
    return _spine_rtti_dispose(
      self,
    );
  }

  late final _spine_rtti_disposePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_rtti)>>('spine_rtti_dispose');
  late final _spine_rtti_dispose = _spine_rtti_disposePtr.asFunction<void Function(spine_rtti)>();

  ffi.Pointer<ffi.Char> spine_rtti_get_class_name(
    spine_rtti self,
  ) {
    return _spine_rtti_get_class_name(
      self,
    );
  }

  late final _spine_rtti_get_class_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_rtti)>>('spine_rtti_get_class_name');
  late final _spine_rtti_get_class_name =
      _spine_rtti_get_class_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_rtti)>();

  bool spine_rtti_is_exactly(
    spine_rtti self,
    spine_rtti rtti,
  ) {
    return _spine_rtti_is_exactly(
      self,
      rtti,
    );
  }

  late final _spine_rtti_is_exactlyPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_rtti, spine_rtti)>>('spine_rtti_is_exactly');
  late final _spine_rtti_is_exactly = _spine_rtti_is_exactlyPtr.asFunction<bool Function(spine_rtti, spine_rtti)>();

  bool spine_rtti_instance_of(
    spine_rtti self,
    spine_rtti rtti,
  ) {
    return _spine_rtti_instance_of(
      self,
      rtti,
    );
  }

  late final _spine_rtti_instance_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_rtti, spine_rtti)>>('spine_rtti_instance_of');
  late final _spine_rtti_instance_of = _spine_rtti_instance_ofPtr.asFunction<bool Function(spine_rtti, spine_rtti)>();

  spine_scale_timeline spine_scale_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_scale_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_scale_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_scale_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_scale_timeline_create');
  late final _spine_scale_timeline_create =
      _spine_scale_timeline_createPtr.asFunction<spine_scale_timeline Function(int, int, int)>();

  void spine_scale_timeline_dispose(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_dispose(
      self,
    );
  }

  late final _spine_scale_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_timeline)>>('spine_scale_timeline_dispose');
  late final _spine_scale_timeline_dispose =
      _spine_scale_timeline_disposePtr.asFunction<void Function(spine_scale_timeline)>();

  spine_rtti spine_scale_timeline_get_rtti(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_rtti(
      self,
    );
  }

  late final _spine_scale_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_scale_timeline)>>('spine_scale_timeline_get_rtti');
  late final _spine_scale_timeline_get_rtti =
      _spine_scale_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_scale_timeline)>();

  void spine_scale_timeline_apply(
    spine_scale_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_scale_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_scale_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_scale_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_scale_timeline_apply');
  late final _spine_scale_timeline_apply = _spine_scale_timeline_applyPtr.asFunction<
      void Function(spine_scale_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_scale_timeline_get_bone_index(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_scale_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_scale_timeline)>>('spine_scale_timeline_get_bone_index');
  late final _spine_scale_timeline_get_bone_index =
      _spine_scale_timeline_get_bone_indexPtr.asFunction<int Function(spine_scale_timeline)>();

  void spine_scale_timeline_set_bone_index(
    spine_scale_timeline self,
    int inValue,
  ) {
    return _spine_scale_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_scale_timeline_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_timeline, ffi.Int)>>(
          'spine_scale_timeline_set_bone_index');
  late final _spine_scale_timeline_set_bone_index =
      _spine_scale_timeline_set_bone_indexPtr.asFunction<void Function(spine_scale_timeline, int)>();

  void spine_scale_timeline_set_frame(
    spine_scale_timeline self,
    int frame,
    double time,
    double value1,
    double value2,
  ) {
    return _spine_scale_timeline_set_frame(
      self,
      frame,
      time,
      value1,
      value2,
    );
  }

  late final _spine_scale_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_timeline, ffi.Size, ffi.Float, ffi.Float, ffi.Float)>>(
          'spine_scale_timeline_set_frame');
  late final _spine_scale_timeline_set_frame =
      _spine_scale_timeline_set_framePtr.asFunction<void Function(spine_scale_timeline, int, double, double, double)>();

  void spine_scale_timeline_set_linear(
    spine_scale_timeline self,
    int frame,
  ) {
    return _spine_scale_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_scale_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_timeline, ffi.Size)>>('spine_scale_timeline_set_linear');
  late final _spine_scale_timeline_set_linear =
      _spine_scale_timeline_set_linearPtr.asFunction<void Function(spine_scale_timeline, int)>();

  void spine_scale_timeline_set_stepped(
    spine_scale_timeline self,
    int frame,
  ) {
    return _spine_scale_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_scale_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_timeline, ffi.Size)>>(
          'spine_scale_timeline_set_stepped');
  late final _spine_scale_timeline_set_stepped =
      _spine_scale_timeline_set_steppedPtr.asFunction<void Function(spine_scale_timeline, int)>();

  void spine_scale_timeline_set_bezier(
    spine_scale_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_scale_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_scale_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_scale_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_scale_timeline_set_bezier');
  late final _spine_scale_timeline_set_bezier = _spine_scale_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_scale_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_scale_timeline_get_bezier_value(
    spine_scale_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_scale_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_scale_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_scale_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_scale_timeline_get_bezier_value');
  late final _spine_scale_timeline_get_bezier_value = _spine_scale_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_scale_timeline, double, int, int, int)>();

  spine_array_float spine_scale_timeline_get_curves(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_curves(
      self,
    );
  }

  late final _spine_scale_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_scale_timeline)>>('spine_scale_timeline_get_curves');
  late final _spine_scale_timeline_get_curves =
      _spine_scale_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_scale_timeline)>();

  int spine_scale_timeline_get_frame_entries(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_scale_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_scale_timeline)>>('spine_scale_timeline_get_frame_entries');
  late final _spine_scale_timeline_get_frame_entries =
      _spine_scale_timeline_get_frame_entriesPtr.asFunction<int Function(spine_scale_timeline)>();

  int spine_scale_timeline_get_frame_count(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_scale_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_scale_timeline)>>('spine_scale_timeline_get_frame_count');
  late final _spine_scale_timeline_get_frame_count =
      _spine_scale_timeline_get_frame_countPtr.asFunction<int Function(spine_scale_timeline)>();

  spine_array_float spine_scale_timeline_get_frames(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_frames(
      self,
    );
  }

  late final _spine_scale_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_scale_timeline)>>('spine_scale_timeline_get_frames');
  late final _spine_scale_timeline_get_frames =
      _spine_scale_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_scale_timeline)>();

  double spine_scale_timeline_get_duration(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_duration(
      self,
    );
  }

  late final _spine_scale_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_scale_timeline)>>('spine_scale_timeline_get_duration');
  late final _spine_scale_timeline_get_duration =
      _spine_scale_timeline_get_durationPtr.asFunction<double Function(spine_scale_timeline)>();

  spine_array_property_id spine_scale_timeline_get_property_ids(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_scale_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_scale_timeline)>>(
          'spine_scale_timeline_get_property_ids');
  late final _spine_scale_timeline_get_property_ids =
      _spine_scale_timeline_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_scale_timeline)>();

  spine_rtti spine_scale_timeline_rtti() {
    return _spine_scale_timeline_rtti();
  }

  late final _spine_scale_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_scale_timeline_rtti');
  late final _spine_scale_timeline_rtti = _spine_scale_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_scale_x_timeline spine_scale_x_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_scale_x_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_scale_x_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_scale_x_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_scale_x_timeline_create');
  late final _spine_scale_x_timeline_create =
      _spine_scale_x_timeline_createPtr.asFunction<spine_scale_x_timeline Function(int, int, int)>();

  void spine_scale_x_timeline_dispose(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_dispose(
      self,
    );
  }

  late final _spine_scale_x_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_x_timeline)>>('spine_scale_x_timeline_dispose');
  late final _spine_scale_x_timeline_dispose =
      _spine_scale_x_timeline_disposePtr.asFunction<void Function(spine_scale_x_timeline)>();

  spine_rtti spine_scale_x_timeline_get_rtti(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_rtti(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_scale_x_timeline)>>('spine_scale_x_timeline_get_rtti');
  late final _spine_scale_x_timeline_get_rtti =
      _spine_scale_x_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_scale_x_timeline)>();

  void spine_scale_x_timeline_apply(
    spine_scale_x_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_scale_x_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_scale_x_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_scale_x_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_scale_x_timeline_apply');
  late final _spine_scale_x_timeline_apply = _spine_scale_x_timeline_applyPtr.asFunction<
      void Function(
          spine_scale_x_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_scale_x_timeline_get_bone_index(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_scale_x_timeline)>>('spine_scale_x_timeline_get_bone_index');
  late final _spine_scale_x_timeline_get_bone_index =
      _spine_scale_x_timeline_get_bone_indexPtr.asFunction<int Function(spine_scale_x_timeline)>();

  void spine_scale_x_timeline_set_bone_index(
    spine_scale_x_timeline self,
    int inValue,
  ) {
    return _spine_scale_x_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_scale_x_timeline_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_x_timeline, ffi.Int)>>(
          'spine_scale_x_timeline_set_bone_index');
  late final _spine_scale_x_timeline_set_bone_index =
      _spine_scale_x_timeline_set_bone_indexPtr.asFunction<void Function(spine_scale_x_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_scale_x_timeline_set_frame(
    spine_scale_x_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_scale_x_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_scale_x_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_x_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_scale_x_timeline_set_frame');
  late final _spine_scale_x_timeline_set_frame =
      _spine_scale_x_timeline_set_framePtr.asFunction<void Function(spine_scale_x_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_scale_x_timeline_get_curve_value(
    spine_scale_x_timeline self,
    double time,
  ) {
    return _spine_scale_x_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_scale_x_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_scale_x_timeline, ffi.Float)>>(
          'spine_scale_x_timeline_get_curve_value');
  late final _spine_scale_x_timeline_get_curve_value =
      _spine_scale_x_timeline_get_curve_valuePtr.asFunction<double Function(spine_scale_x_timeline, double)>();

  double spine_scale_x_timeline_get_relative_value(
    spine_scale_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_scale_x_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_scale_x_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_scale_x_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_scale_x_timeline_get_relative_value');
  late final _spine_scale_x_timeline_get_relative_value = _spine_scale_x_timeline_get_relative_valuePtr
      .asFunction<double Function(spine_scale_x_timeline, double, double, int, double, double)>();

  double spine_scale_x_timeline_get_absolute_value_1(
    spine_scale_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_scale_x_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_scale_x_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_scale_x_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_scale_x_timeline_get_absolute_value_1');
  late final _spine_scale_x_timeline_get_absolute_value_1 = _spine_scale_x_timeline_get_absolute_value_1Ptr
      .asFunction<double Function(spine_scale_x_timeline, double, double, int, double, double)>();

  double spine_scale_x_timeline_get_absolute_value_2(
    spine_scale_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_scale_x_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_scale_x_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_scale_x_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_scale_x_timeline_get_absolute_value_2');
  late final _spine_scale_x_timeline_get_absolute_value_2 = _spine_scale_x_timeline_get_absolute_value_2Ptr
      .asFunction<double Function(spine_scale_x_timeline, double, double, int, double, double, double)>();

  double spine_scale_x_timeline_get_scale_value(
    spine_scale_x_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_scale_x_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_scale_x_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_scale_x_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_scale_x_timeline_get_scale_value');
  late final _spine_scale_x_timeline_get_scale_value = _spine_scale_x_timeline_get_scale_valuePtr
      .asFunction<double Function(spine_scale_x_timeline, double, double, int, int, double, double)>();

  void spine_scale_x_timeline_set_linear(
    spine_scale_x_timeline self,
    int frame,
  ) {
    return _spine_scale_x_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_scale_x_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_x_timeline, ffi.Size)>>(
          'spine_scale_x_timeline_set_linear');
  late final _spine_scale_x_timeline_set_linear =
      _spine_scale_x_timeline_set_linearPtr.asFunction<void Function(spine_scale_x_timeline, int)>();

  void spine_scale_x_timeline_set_stepped(
    spine_scale_x_timeline self,
    int frame,
  ) {
    return _spine_scale_x_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_scale_x_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_x_timeline, ffi.Size)>>(
          'spine_scale_x_timeline_set_stepped');
  late final _spine_scale_x_timeline_set_stepped =
      _spine_scale_x_timeline_set_steppedPtr.asFunction<void Function(spine_scale_x_timeline, int)>();

  void spine_scale_x_timeline_set_bezier(
    spine_scale_x_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_scale_x_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_scale_x_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_scale_x_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_scale_x_timeline_set_bezier');
  late final _spine_scale_x_timeline_set_bezier = _spine_scale_x_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_scale_x_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_scale_x_timeline_get_bezier_value(
    spine_scale_x_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_scale_x_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_scale_x_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_scale_x_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_scale_x_timeline_get_bezier_value');
  late final _spine_scale_x_timeline_get_bezier_value = _spine_scale_x_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_scale_x_timeline, double, int, int, int)>();

  spine_array_float spine_scale_x_timeline_get_curves(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_curves(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_get_curves');
  late final _spine_scale_x_timeline_get_curves =
      _spine_scale_x_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_scale_x_timeline)>();

  int spine_scale_x_timeline_get_frame_entries(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_get_frame_entries');
  late final _spine_scale_x_timeline_get_frame_entries =
      _spine_scale_x_timeline_get_frame_entriesPtr.asFunction<int Function(spine_scale_x_timeline)>();

  int spine_scale_x_timeline_get_frame_count(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_scale_x_timeline)>>('spine_scale_x_timeline_get_frame_count');
  late final _spine_scale_x_timeline_get_frame_count =
      _spine_scale_x_timeline_get_frame_countPtr.asFunction<int Function(spine_scale_x_timeline)>();

  spine_array_float spine_scale_x_timeline_get_frames(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_frames(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_get_frames');
  late final _spine_scale_x_timeline_get_frames =
      _spine_scale_x_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_scale_x_timeline)>();

  double spine_scale_x_timeline_get_duration(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_duration(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_scale_x_timeline)>>('spine_scale_x_timeline_get_duration');
  late final _spine_scale_x_timeline_get_duration =
      _spine_scale_x_timeline_get_durationPtr.asFunction<double Function(spine_scale_x_timeline)>();

  spine_array_property_id spine_scale_x_timeline_get_property_ids(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_get_property_ids');
  late final _spine_scale_x_timeline_get_property_ids = _spine_scale_x_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_scale_x_timeline)>();

  spine_rtti spine_scale_x_timeline_rtti() {
    return _spine_scale_x_timeline_rtti();
  }

  late final _spine_scale_x_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_scale_x_timeline_rtti');
  late final _spine_scale_x_timeline_rtti = _spine_scale_x_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_scale_y_timeline spine_scale_y_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_scale_y_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_scale_y_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_scale_y_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_scale_y_timeline_create');
  late final _spine_scale_y_timeline_create =
      _spine_scale_y_timeline_createPtr.asFunction<spine_scale_y_timeline Function(int, int, int)>();

  void spine_scale_y_timeline_dispose(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_dispose(
      self,
    );
  }

  late final _spine_scale_y_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_y_timeline)>>('spine_scale_y_timeline_dispose');
  late final _spine_scale_y_timeline_dispose =
      _spine_scale_y_timeline_disposePtr.asFunction<void Function(spine_scale_y_timeline)>();

  spine_rtti spine_scale_y_timeline_get_rtti(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_rtti(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_scale_y_timeline)>>('spine_scale_y_timeline_get_rtti');
  late final _spine_scale_y_timeline_get_rtti =
      _spine_scale_y_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_scale_y_timeline)>();

  void spine_scale_y_timeline_apply(
    spine_scale_y_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_scale_y_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_scale_y_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_scale_y_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_scale_y_timeline_apply');
  late final _spine_scale_y_timeline_apply = _spine_scale_y_timeline_applyPtr.asFunction<
      void Function(
          spine_scale_y_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_scale_y_timeline_get_bone_index(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_scale_y_timeline)>>('spine_scale_y_timeline_get_bone_index');
  late final _spine_scale_y_timeline_get_bone_index =
      _spine_scale_y_timeline_get_bone_indexPtr.asFunction<int Function(spine_scale_y_timeline)>();

  void spine_scale_y_timeline_set_bone_index(
    spine_scale_y_timeline self,
    int inValue,
  ) {
    return _spine_scale_y_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_scale_y_timeline_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_y_timeline, ffi.Int)>>(
          'spine_scale_y_timeline_set_bone_index');
  late final _spine_scale_y_timeline_set_bone_index =
      _spine_scale_y_timeline_set_bone_indexPtr.asFunction<void Function(spine_scale_y_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_scale_y_timeline_set_frame(
    spine_scale_y_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_scale_y_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_scale_y_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_y_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_scale_y_timeline_set_frame');
  late final _spine_scale_y_timeline_set_frame =
      _spine_scale_y_timeline_set_framePtr.asFunction<void Function(spine_scale_y_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_scale_y_timeline_get_curve_value(
    spine_scale_y_timeline self,
    double time,
  ) {
    return _spine_scale_y_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_scale_y_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_scale_y_timeline, ffi.Float)>>(
          'spine_scale_y_timeline_get_curve_value');
  late final _spine_scale_y_timeline_get_curve_value =
      _spine_scale_y_timeline_get_curve_valuePtr.asFunction<double Function(spine_scale_y_timeline, double)>();

  double spine_scale_y_timeline_get_relative_value(
    spine_scale_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_scale_y_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_scale_y_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_scale_y_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_scale_y_timeline_get_relative_value');
  late final _spine_scale_y_timeline_get_relative_value = _spine_scale_y_timeline_get_relative_valuePtr
      .asFunction<double Function(spine_scale_y_timeline, double, double, int, double, double)>();

  double spine_scale_y_timeline_get_absolute_value_1(
    spine_scale_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_scale_y_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_scale_y_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_scale_y_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_scale_y_timeline_get_absolute_value_1');
  late final _spine_scale_y_timeline_get_absolute_value_1 = _spine_scale_y_timeline_get_absolute_value_1Ptr
      .asFunction<double Function(spine_scale_y_timeline, double, double, int, double, double)>();

  double spine_scale_y_timeline_get_absolute_value_2(
    spine_scale_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_scale_y_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_scale_y_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_scale_y_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_scale_y_timeline_get_absolute_value_2');
  late final _spine_scale_y_timeline_get_absolute_value_2 = _spine_scale_y_timeline_get_absolute_value_2Ptr
      .asFunction<double Function(spine_scale_y_timeline, double, double, int, double, double, double)>();

  double spine_scale_y_timeline_get_scale_value(
    spine_scale_y_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_scale_y_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_scale_y_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_scale_y_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_scale_y_timeline_get_scale_value');
  late final _spine_scale_y_timeline_get_scale_value = _spine_scale_y_timeline_get_scale_valuePtr
      .asFunction<double Function(spine_scale_y_timeline, double, double, int, int, double, double)>();

  void spine_scale_y_timeline_set_linear(
    spine_scale_y_timeline self,
    int frame,
  ) {
    return _spine_scale_y_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_scale_y_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_y_timeline, ffi.Size)>>(
          'spine_scale_y_timeline_set_linear');
  late final _spine_scale_y_timeline_set_linear =
      _spine_scale_y_timeline_set_linearPtr.asFunction<void Function(spine_scale_y_timeline, int)>();

  void spine_scale_y_timeline_set_stepped(
    spine_scale_y_timeline self,
    int frame,
  ) {
    return _spine_scale_y_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_scale_y_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_y_timeline, ffi.Size)>>(
          'spine_scale_y_timeline_set_stepped');
  late final _spine_scale_y_timeline_set_stepped =
      _spine_scale_y_timeline_set_steppedPtr.asFunction<void Function(spine_scale_y_timeline, int)>();

  void spine_scale_y_timeline_set_bezier(
    spine_scale_y_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_scale_y_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_scale_y_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_scale_y_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_scale_y_timeline_set_bezier');
  late final _spine_scale_y_timeline_set_bezier = _spine_scale_y_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_scale_y_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_scale_y_timeline_get_bezier_value(
    spine_scale_y_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_scale_y_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_scale_y_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_scale_y_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_scale_y_timeline_get_bezier_value');
  late final _spine_scale_y_timeline_get_bezier_value = _spine_scale_y_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_scale_y_timeline, double, int, int, int)>();

  spine_array_float spine_scale_y_timeline_get_curves(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_curves(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_get_curves');
  late final _spine_scale_y_timeline_get_curves =
      _spine_scale_y_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_scale_y_timeline)>();

  int spine_scale_y_timeline_get_frame_entries(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_get_frame_entries');
  late final _spine_scale_y_timeline_get_frame_entries =
      _spine_scale_y_timeline_get_frame_entriesPtr.asFunction<int Function(spine_scale_y_timeline)>();

  int spine_scale_y_timeline_get_frame_count(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_scale_y_timeline)>>('spine_scale_y_timeline_get_frame_count');
  late final _spine_scale_y_timeline_get_frame_count =
      _spine_scale_y_timeline_get_frame_countPtr.asFunction<int Function(spine_scale_y_timeline)>();

  spine_array_float spine_scale_y_timeline_get_frames(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_frames(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_get_frames');
  late final _spine_scale_y_timeline_get_frames =
      _spine_scale_y_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_scale_y_timeline)>();

  double spine_scale_y_timeline_get_duration(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_duration(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_scale_y_timeline)>>('spine_scale_y_timeline_get_duration');
  late final _spine_scale_y_timeline_get_duration =
      _spine_scale_y_timeline_get_durationPtr.asFunction<double Function(spine_scale_y_timeline)>();

  spine_array_property_id spine_scale_y_timeline_get_property_ids(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_get_property_ids');
  late final _spine_scale_y_timeline_get_property_ids = _spine_scale_y_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_scale_y_timeline)>();

  spine_rtti spine_scale_y_timeline_rtti() {
    return _spine_scale_y_timeline_rtti();
  }

  late final _spine_scale_y_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_scale_y_timeline_rtti');
  late final _spine_scale_y_timeline_rtti = _spine_scale_y_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_sequence spine_sequence_create(
    int count,
  ) {
    return _spine_sequence_create(
      count,
    );
  }

  late final _spine_sequence_createPtr =
      _lookup<ffi.NativeFunction<spine_sequence Function(ffi.Int)>>('spine_sequence_create');
  late final _spine_sequence_create = _spine_sequence_createPtr.asFunction<spine_sequence Function(int)>();

  void spine_sequence_dispose(
    spine_sequence self,
  ) {
    return _spine_sequence_dispose(
      self,
    );
  }

  late final _spine_sequence_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence)>>('spine_sequence_dispose');
  late final _spine_sequence_dispose = _spine_sequence_disposePtr.asFunction<void Function(spine_sequence)>();

  spine_sequence spine_sequence_copy(
    spine_sequence self,
  ) {
    return _spine_sequence_copy(
      self,
    );
  }

  late final _spine_sequence_copyPtr =
      _lookup<ffi.NativeFunction<spine_sequence Function(spine_sequence)>>('spine_sequence_copy');
  late final _spine_sequence_copy = _spine_sequence_copyPtr.asFunction<spine_sequence Function(spine_sequence)>();

  void spine_sequence_apply(
    spine_sequence self,
    spine_slot_pose slot,
    spine_attachment attachment,
  ) {
    return _spine_sequence_apply(
      self,
      slot,
      attachment,
    );
  }

  late final _spine_sequence_applyPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, spine_slot_pose, spine_attachment)>>(
          'spine_sequence_apply');
  late final _spine_sequence_apply =
      _spine_sequence_applyPtr.asFunction<void Function(spine_sequence, spine_slot_pose, spine_attachment)>();

  ffi.Pointer<ffi.Char> spine_sequence_get_path(
    spine_sequence self,
    ffi.Pointer<ffi.Char> basePath,
    int index,
  ) {
    return _spine_sequence_get_path(
      self,
      basePath,
      index,
    );
  }

  late final _spine_sequence_get_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_sequence, ffi.Pointer<ffi.Char>, ffi.Int)>>(
          'spine_sequence_get_path');
  late final _spine_sequence_get_path = _spine_sequence_get_pathPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_sequence, ffi.Pointer<ffi.Char>, int)>();

  /// Returns a unique ID for this attachment.
  int spine_sequence_get_id(
    spine_sequence self,
  ) {
    return _spine_sequence_get_id(
      self,
    );
  }

  late final _spine_sequence_get_idPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_sequence)>>('spine_sequence_get_id');
  late final _spine_sequence_get_id = _spine_sequence_get_idPtr.asFunction<int Function(spine_sequence)>();

  void spine_sequence_set_id(
    spine_sequence self,
    int id,
  ) {
    return _spine_sequence_set_id(
      self,
      id,
    );
  }

  late final _spine_sequence_set_idPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int)>>('spine_sequence_set_id');
  late final _spine_sequence_set_id = _spine_sequence_set_idPtr.asFunction<void Function(spine_sequence, int)>();

  int spine_sequence_get_start(
    spine_sequence self,
  ) {
    return _spine_sequence_get_start(
      self,
    );
  }

  late final _spine_sequence_get_startPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_sequence)>>('spine_sequence_get_start');
  late final _spine_sequence_get_start = _spine_sequence_get_startPtr.asFunction<int Function(spine_sequence)>();

  void spine_sequence_set_start(
    spine_sequence self,
    int start,
  ) {
    return _spine_sequence_set_start(
      self,
      start,
    );
  }

  late final _spine_sequence_set_startPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int)>>('spine_sequence_set_start');
  late final _spine_sequence_set_start = _spine_sequence_set_startPtr.asFunction<void Function(spine_sequence, int)>();

  int spine_sequence_get_digits(
    spine_sequence self,
  ) {
    return _spine_sequence_get_digits(
      self,
    );
  }

  late final _spine_sequence_get_digitsPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_sequence)>>('spine_sequence_get_digits');
  late final _spine_sequence_get_digits = _spine_sequence_get_digitsPtr.asFunction<int Function(spine_sequence)>();

  void spine_sequence_set_digits(
    spine_sequence self,
    int digits,
  ) {
    return _spine_sequence_set_digits(
      self,
      digits,
    );
  }

  late final _spine_sequence_set_digitsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int)>>('spine_sequence_set_digits');
  late final _spine_sequence_set_digits =
      _spine_sequence_set_digitsPtr.asFunction<void Function(spine_sequence, int)>();

  /// The index of the region to show for the setup pose.
  int spine_sequence_get_setup_index(
    spine_sequence self,
  ) {
    return _spine_sequence_get_setup_index(
      self,
    );
  }

  late final _spine_sequence_get_setup_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_sequence)>>('spine_sequence_get_setup_index');
  late final _spine_sequence_get_setup_index =
      _spine_sequence_get_setup_indexPtr.asFunction<int Function(spine_sequence)>();

  void spine_sequence_set_setup_index(
    spine_sequence self,
    int setupIndex,
  ) {
    return _spine_sequence_set_setup_index(
      self,
      setupIndex,
    );
  }

  late final _spine_sequence_set_setup_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int)>>('spine_sequence_set_setup_index');
  late final _spine_sequence_set_setup_index =
      _spine_sequence_set_setup_indexPtr.asFunction<void Function(spine_sequence, int)>();

  spine_array_texture_region spine_sequence_get_regions(
    spine_sequence self,
  ) {
    return _spine_sequence_get_regions(
      self,
    );
  }

  late final _spine_sequence_get_regionsPtr =
      _lookup<ffi.NativeFunction<spine_array_texture_region Function(spine_sequence)>>('spine_sequence_get_regions');
  late final _spine_sequence_get_regions =
      _spine_sequence_get_regionsPtr.asFunction<spine_array_texture_region Function(spine_sequence)>();

  spine_sequence_timeline spine_sequence_timeline_create(
    int frameCount,
    int slotIndex,
    spine_attachment attachment,
  ) {
    return _spine_sequence_timeline_create(
      frameCount,
      slotIndex,
      attachment,
    );
  }

  late final _spine_sequence_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_sequence_timeline Function(ffi.Size, ffi.Int, spine_attachment)>>(
          'spine_sequence_timeline_create');
  late final _spine_sequence_timeline_create =
      _spine_sequence_timeline_createPtr.asFunction<spine_sequence_timeline Function(int, int, spine_attachment)>();

  void spine_sequence_timeline_dispose(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_dispose(
      self,
    );
  }

  late final _spine_sequence_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence_timeline)>>('spine_sequence_timeline_dispose');
  late final _spine_sequence_timeline_dispose =
      _spine_sequence_timeline_disposePtr.asFunction<void Function(spine_sequence_timeline)>();

  spine_rtti spine_sequence_timeline_get_rtti(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_rtti(
      self,
    );
  }

  late final _spine_sequence_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_sequence_timeline)>>('spine_sequence_timeline_get_rtti');
  late final _spine_sequence_timeline_get_rtti =
      _spine_sequence_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_sequence_timeline)>();

  void spine_sequence_timeline_apply(
    spine_sequence_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_sequence_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_sequence_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_sequence_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_sequence_timeline_apply');
  late final _spine_sequence_timeline_apply = _spine_sequence_timeline_applyPtr.asFunction<
      void Function(
          spine_sequence_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  /// Sets the time, mode, index, and frame time for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param delay Seconds between frames.
  void spine_sequence_timeline_set_frame(
    spine_sequence_timeline self,
    int frame,
    double time,
    int mode,
    int index,
    double delay,
  ) {
    return _spine_sequence_timeline_set_frame(
      self,
      frame,
      time,
      mode,
      index,
      delay,
    );
  }

  late final _spine_sequence_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_sequence_timeline, ffi.Int, ffi.Float, ffi.Int32, ffi.Int,
              ffi.Float)>>('spine_sequence_timeline_set_frame');
  late final _spine_sequence_timeline_set_frame = _spine_sequence_timeline_set_framePtr
      .asFunction<void Function(spine_sequence_timeline, int, double, int, int, double)>();

  spine_attachment spine_sequence_timeline_get_attachment(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_attachment(
      self,
    );
  }

  late final _spine_sequence_timeline_get_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_sequence_timeline)>>(
          'spine_sequence_timeline_get_attachment');
  late final _spine_sequence_timeline_get_attachment =
      _spine_sequence_timeline_get_attachmentPtr.asFunction<spine_attachment Function(spine_sequence_timeline)>();

  int spine_sequence_timeline_get_slot_index(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_sequence_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_sequence_timeline)>>('spine_sequence_timeline_get_slot_index');
  late final _spine_sequence_timeline_get_slot_index =
      _spine_sequence_timeline_get_slot_indexPtr.asFunction<int Function(spine_sequence_timeline)>();

  void spine_sequence_timeline_set_slot_index(
    spine_sequence_timeline self,
    int inValue,
  ) {
    return _spine_sequence_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_sequence_timeline_set_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence_timeline, ffi.Int)>>(
          'spine_sequence_timeline_set_slot_index');
  late final _spine_sequence_timeline_set_slot_index =
      _spine_sequence_timeline_set_slot_indexPtr.asFunction<void Function(spine_sequence_timeline, int)>();

  int spine_sequence_timeline_get_frame_entries(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_sequence_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_sequence_timeline)>>(
          'spine_sequence_timeline_get_frame_entries');
  late final _spine_sequence_timeline_get_frame_entries =
      _spine_sequence_timeline_get_frame_entriesPtr.asFunction<int Function(spine_sequence_timeline)>();

  int spine_sequence_timeline_get_frame_count(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_sequence_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_sequence_timeline)>>(
          'spine_sequence_timeline_get_frame_count');
  late final _spine_sequence_timeline_get_frame_count =
      _spine_sequence_timeline_get_frame_countPtr.asFunction<int Function(spine_sequence_timeline)>();

  spine_array_float spine_sequence_timeline_get_frames(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_frames(
      self,
    );
  }

  late final _spine_sequence_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_sequence_timeline)>>(
          'spine_sequence_timeline_get_frames');
  late final _spine_sequence_timeline_get_frames =
      _spine_sequence_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_sequence_timeline)>();

  double spine_sequence_timeline_get_duration(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_duration(
      self,
    );
  }

  late final _spine_sequence_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_sequence_timeline)>>('spine_sequence_timeline_get_duration');
  late final _spine_sequence_timeline_get_duration =
      _spine_sequence_timeline_get_durationPtr.asFunction<double Function(spine_sequence_timeline)>();

  spine_array_property_id spine_sequence_timeline_get_property_ids(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_sequence_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_sequence_timeline)>>(
          'spine_sequence_timeline_get_property_ids');
  late final _spine_sequence_timeline_get_property_ids = _spine_sequence_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_sequence_timeline)>();

  spine_rtti spine_sequence_timeline_rtti() {
    return _spine_sequence_timeline_rtti();
  }

  late final _spine_sequence_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_sequence_timeline_rtti');
  late final _spine_sequence_timeline_rtti = _spine_sequence_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_shear_timeline spine_shear_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_shear_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_shear_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_shear_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_shear_timeline_create');
  late final _spine_shear_timeline_create =
      _spine_shear_timeline_createPtr.asFunction<spine_shear_timeline Function(int, int, int)>();

  void spine_shear_timeline_dispose(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_dispose(
      self,
    );
  }

  late final _spine_shear_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_timeline)>>('spine_shear_timeline_dispose');
  late final _spine_shear_timeline_dispose =
      _spine_shear_timeline_disposePtr.asFunction<void Function(spine_shear_timeline)>();

  spine_rtti spine_shear_timeline_get_rtti(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_rtti(
      self,
    );
  }

  late final _spine_shear_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_shear_timeline)>>('spine_shear_timeline_get_rtti');
  late final _spine_shear_timeline_get_rtti =
      _spine_shear_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_shear_timeline)>();

  void spine_shear_timeline_apply(
    spine_shear_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_shear_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_shear_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_shear_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_shear_timeline_apply');
  late final _spine_shear_timeline_apply = _spine_shear_timeline_applyPtr.asFunction<
      void Function(spine_shear_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_shear_timeline_get_bone_index(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_shear_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_shear_timeline)>>('spine_shear_timeline_get_bone_index');
  late final _spine_shear_timeline_get_bone_index =
      _spine_shear_timeline_get_bone_indexPtr.asFunction<int Function(spine_shear_timeline)>();

  void spine_shear_timeline_set_bone_index(
    spine_shear_timeline self,
    int inValue,
  ) {
    return _spine_shear_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_shear_timeline_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_timeline, ffi.Int)>>(
          'spine_shear_timeline_set_bone_index');
  late final _spine_shear_timeline_set_bone_index =
      _spine_shear_timeline_set_bone_indexPtr.asFunction<void Function(spine_shear_timeline, int)>();

  void spine_shear_timeline_set_frame(
    spine_shear_timeline self,
    int frame,
    double time,
    double value1,
    double value2,
  ) {
    return _spine_shear_timeline_set_frame(
      self,
      frame,
      time,
      value1,
      value2,
    );
  }

  late final _spine_shear_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_timeline, ffi.Size, ffi.Float, ffi.Float, ffi.Float)>>(
          'spine_shear_timeline_set_frame');
  late final _spine_shear_timeline_set_frame =
      _spine_shear_timeline_set_framePtr.asFunction<void Function(spine_shear_timeline, int, double, double, double)>();

  void spine_shear_timeline_set_linear(
    spine_shear_timeline self,
    int frame,
  ) {
    return _spine_shear_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_shear_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_timeline, ffi.Size)>>('spine_shear_timeline_set_linear');
  late final _spine_shear_timeline_set_linear =
      _spine_shear_timeline_set_linearPtr.asFunction<void Function(spine_shear_timeline, int)>();

  void spine_shear_timeline_set_stepped(
    spine_shear_timeline self,
    int frame,
  ) {
    return _spine_shear_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_shear_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_timeline, ffi.Size)>>(
          'spine_shear_timeline_set_stepped');
  late final _spine_shear_timeline_set_stepped =
      _spine_shear_timeline_set_steppedPtr.asFunction<void Function(spine_shear_timeline, int)>();

  void spine_shear_timeline_set_bezier(
    spine_shear_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_shear_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_shear_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_shear_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_shear_timeline_set_bezier');
  late final _spine_shear_timeline_set_bezier = _spine_shear_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_shear_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_shear_timeline_get_bezier_value(
    spine_shear_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_shear_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_shear_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_shear_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_shear_timeline_get_bezier_value');
  late final _spine_shear_timeline_get_bezier_value = _spine_shear_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_shear_timeline, double, int, int, int)>();

  spine_array_float spine_shear_timeline_get_curves(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_curves(
      self,
    );
  }

  late final _spine_shear_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_shear_timeline)>>('spine_shear_timeline_get_curves');
  late final _spine_shear_timeline_get_curves =
      _spine_shear_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_shear_timeline)>();

  int spine_shear_timeline_get_frame_entries(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_shear_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_shear_timeline)>>('spine_shear_timeline_get_frame_entries');
  late final _spine_shear_timeline_get_frame_entries =
      _spine_shear_timeline_get_frame_entriesPtr.asFunction<int Function(spine_shear_timeline)>();

  int spine_shear_timeline_get_frame_count(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_shear_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_shear_timeline)>>('spine_shear_timeline_get_frame_count');
  late final _spine_shear_timeline_get_frame_count =
      _spine_shear_timeline_get_frame_countPtr.asFunction<int Function(spine_shear_timeline)>();

  spine_array_float spine_shear_timeline_get_frames(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_frames(
      self,
    );
  }

  late final _spine_shear_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_shear_timeline)>>('spine_shear_timeline_get_frames');
  late final _spine_shear_timeline_get_frames =
      _spine_shear_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_shear_timeline)>();

  double spine_shear_timeline_get_duration(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_duration(
      self,
    );
  }

  late final _spine_shear_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_shear_timeline)>>('spine_shear_timeline_get_duration');
  late final _spine_shear_timeline_get_duration =
      _spine_shear_timeline_get_durationPtr.asFunction<double Function(spine_shear_timeline)>();

  spine_array_property_id spine_shear_timeline_get_property_ids(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_shear_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_shear_timeline)>>(
          'spine_shear_timeline_get_property_ids');
  late final _spine_shear_timeline_get_property_ids =
      _spine_shear_timeline_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_shear_timeline)>();

  spine_rtti spine_shear_timeline_rtti() {
    return _spine_shear_timeline_rtti();
  }

  late final _spine_shear_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_shear_timeline_rtti');
  late final _spine_shear_timeline_rtti = _spine_shear_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_shear_x_timeline spine_shear_x_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_shear_x_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_shear_x_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_shear_x_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_shear_x_timeline_create');
  late final _spine_shear_x_timeline_create =
      _spine_shear_x_timeline_createPtr.asFunction<spine_shear_x_timeline Function(int, int, int)>();

  void spine_shear_x_timeline_dispose(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_dispose(
      self,
    );
  }

  late final _spine_shear_x_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_x_timeline)>>('spine_shear_x_timeline_dispose');
  late final _spine_shear_x_timeline_dispose =
      _spine_shear_x_timeline_disposePtr.asFunction<void Function(spine_shear_x_timeline)>();

  spine_rtti spine_shear_x_timeline_get_rtti(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_rtti(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_shear_x_timeline)>>('spine_shear_x_timeline_get_rtti');
  late final _spine_shear_x_timeline_get_rtti =
      _spine_shear_x_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_shear_x_timeline)>();

  void spine_shear_x_timeline_apply(
    spine_shear_x_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_shear_x_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_shear_x_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_shear_x_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_shear_x_timeline_apply');
  late final _spine_shear_x_timeline_apply = _spine_shear_x_timeline_applyPtr.asFunction<
      void Function(
          spine_shear_x_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_shear_x_timeline_get_bone_index(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_shear_x_timeline)>>('spine_shear_x_timeline_get_bone_index');
  late final _spine_shear_x_timeline_get_bone_index =
      _spine_shear_x_timeline_get_bone_indexPtr.asFunction<int Function(spine_shear_x_timeline)>();

  void spine_shear_x_timeline_set_bone_index(
    spine_shear_x_timeline self,
    int inValue,
  ) {
    return _spine_shear_x_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_shear_x_timeline_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_x_timeline, ffi.Int)>>(
          'spine_shear_x_timeline_set_bone_index');
  late final _spine_shear_x_timeline_set_bone_index =
      _spine_shear_x_timeline_set_bone_indexPtr.asFunction<void Function(spine_shear_x_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_shear_x_timeline_set_frame(
    spine_shear_x_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_shear_x_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_shear_x_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_x_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_shear_x_timeline_set_frame');
  late final _spine_shear_x_timeline_set_frame =
      _spine_shear_x_timeline_set_framePtr.asFunction<void Function(spine_shear_x_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_shear_x_timeline_get_curve_value(
    spine_shear_x_timeline self,
    double time,
  ) {
    return _spine_shear_x_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_shear_x_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_shear_x_timeline, ffi.Float)>>(
          'spine_shear_x_timeline_get_curve_value');
  late final _spine_shear_x_timeline_get_curve_value =
      _spine_shear_x_timeline_get_curve_valuePtr.asFunction<double Function(spine_shear_x_timeline, double)>();

  double spine_shear_x_timeline_get_relative_value(
    spine_shear_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_shear_x_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_shear_x_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_shear_x_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_shear_x_timeline_get_relative_value');
  late final _spine_shear_x_timeline_get_relative_value = _spine_shear_x_timeline_get_relative_valuePtr
      .asFunction<double Function(spine_shear_x_timeline, double, double, int, double, double)>();

  double spine_shear_x_timeline_get_absolute_value_1(
    spine_shear_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_shear_x_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_shear_x_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_shear_x_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_shear_x_timeline_get_absolute_value_1');
  late final _spine_shear_x_timeline_get_absolute_value_1 = _spine_shear_x_timeline_get_absolute_value_1Ptr
      .asFunction<double Function(spine_shear_x_timeline, double, double, int, double, double)>();

  double spine_shear_x_timeline_get_absolute_value_2(
    spine_shear_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_shear_x_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_shear_x_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_shear_x_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_shear_x_timeline_get_absolute_value_2');
  late final _spine_shear_x_timeline_get_absolute_value_2 = _spine_shear_x_timeline_get_absolute_value_2Ptr
      .asFunction<double Function(spine_shear_x_timeline, double, double, int, double, double, double)>();

  double spine_shear_x_timeline_get_scale_value(
    spine_shear_x_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_shear_x_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_shear_x_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_shear_x_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_shear_x_timeline_get_scale_value');
  late final _spine_shear_x_timeline_get_scale_value = _spine_shear_x_timeline_get_scale_valuePtr
      .asFunction<double Function(spine_shear_x_timeline, double, double, int, int, double, double)>();

  void spine_shear_x_timeline_set_linear(
    spine_shear_x_timeline self,
    int frame,
  ) {
    return _spine_shear_x_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_shear_x_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_x_timeline, ffi.Size)>>(
          'spine_shear_x_timeline_set_linear');
  late final _spine_shear_x_timeline_set_linear =
      _spine_shear_x_timeline_set_linearPtr.asFunction<void Function(spine_shear_x_timeline, int)>();

  void spine_shear_x_timeline_set_stepped(
    spine_shear_x_timeline self,
    int frame,
  ) {
    return _spine_shear_x_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_shear_x_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_x_timeline, ffi.Size)>>(
          'spine_shear_x_timeline_set_stepped');
  late final _spine_shear_x_timeline_set_stepped =
      _spine_shear_x_timeline_set_steppedPtr.asFunction<void Function(spine_shear_x_timeline, int)>();

  void spine_shear_x_timeline_set_bezier(
    spine_shear_x_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_shear_x_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_shear_x_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_shear_x_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_shear_x_timeline_set_bezier');
  late final _spine_shear_x_timeline_set_bezier = _spine_shear_x_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_shear_x_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_shear_x_timeline_get_bezier_value(
    spine_shear_x_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_shear_x_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_shear_x_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_shear_x_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_shear_x_timeline_get_bezier_value');
  late final _spine_shear_x_timeline_get_bezier_value = _spine_shear_x_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_shear_x_timeline, double, int, int, int)>();

  spine_array_float spine_shear_x_timeline_get_curves(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_curves(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_get_curves');
  late final _spine_shear_x_timeline_get_curves =
      _spine_shear_x_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_shear_x_timeline)>();

  int spine_shear_x_timeline_get_frame_entries(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_get_frame_entries');
  late final _spine_shear_x_timeline_get_frame_entries =
      _spine_shear_x_timeline_get_frame_entriesPtr.asFunction<int Function(spine_shear_x_timeline)>();

  int spine_shear_x_timeline_get_frame_count(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_shear_x_timeline)>>('spine_shear_x_timeline_get_frame_count');
  late final _spine_shear_x_timeline_get_frame_count =
      _spine_shear_x_timeline_get_frame_countPtr.asFunction<int Function(spine_shear_x_timeline)>();

  spine_array_float spine_shear_x_timeline_get_frames(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_frames(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_get_frames');
  late final _spine_shear_x_timeline_get_frames =
      _spine_shear_x_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_shear_x_timeline)>();

  double spine_shear_x_timeline_get_duration(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_duration(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_shear_x_timeline)>>('spine_shear_x_timeline_get_duration');
  late final _spine_shear_x_timeline_get_duration =
      _spine_shear_x_timeline_get_durationPtr.asFunction<double Function(spine_shear_x_timeline)>();

  spine_array_property_id spine_shear_x_timeline_get_property_ids(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_get_property_ids');
  late final _spine_shear_x_timeline_get_property_ids = _spine_shear_x_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_shear_x_timeline)>();

  spine_rtti spine_shear_x_timeline_rtti() {
    return _spine_shear_x_timeline_rtti();
  }

  late final _spine_shear_x_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_shear_x_timeline_rtti');
  late final _spine_shear_x_timeline_rtti = _spine_shear_x_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_shear_y_timeline spine_shear_y_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_shear_y_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_shear_y_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_shear_y_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_shear_y_timeline_create');
  late final _spine_shear_y_timeline_create =
      _spine_shear_y_timeline_createPtr.asFunction<spine_shear_y_timeline Function(int, int, int)>();

  void spine_shear_y_timeline_dispose(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_dispose(
      self,
    );
  }

  late final _spine_shear_y_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_y_timeline)>>('spine_shear_y_timeline_dispose');
  late final _spine_shear_y_timeline_dispose =
      _spine_shear_y_timeline_disposePtr.asFunction<void Function(spine_shear_y_timeline)>();

  spine_rtti spine_shear_y_timeline_get_rtti(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_rtti(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_shear_y_timeline)>>('spine_shear_y_timeline_get_rtti');
  late final _spine_shear_y_timeline_get_rtti =
      _spine_shear_y_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_shear_y_timeline)>();

  void spine_shear_y_timeline_apply(
    spine_shear_y_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_shear_y_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_shear_y_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_shear_y_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_shear_y_timeline_apply');
  late final _spine_shear_y_timeline_apply = _spine_shear_y_timeline_applyPtr.asFunction<
      void Function(
          spine_shear_y_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_shear_y_timeline_get_bone_index(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_shear_y_timeline)>>('spine_shear_y_timeline_get_bone_index');
  late final _spine_shear_y_timeline_get_bone_index =
      _spine_shear_y_timeline_get_bone_indexPtr.asFunction<int Function(spine_shear_y_timeline)>();

  void spine_shear_y_timeline_set_bone_index(
    spine_shear_y_timeline self,
    int inValue,
  ) {
    return _spine_shear_y_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_shear_y_timeline_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_y_timeline, ffi.Int)>>(
          'spine_shear_y_timeline_set_bone_index');
  late final _spine_shear_y_timeline_set_bone_index =
      _spine_shear_y_timeline_set_bone_indexPtr.asFunction<void Function(spine_shear_y_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_shear_y_timeline_set_frame(
    spine_shear_y_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_shear_y_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_shear_y_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_y_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_shear_y_timeline_set_frame');
  late final _spine_shear_y_timeline_set_frame =
      _spine_shear_y_timeline_set_framePtr.asFunction<void Function(spine_shear_y_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_shear_y_timeline_get_curve_value(
    spine_shear_y_timeline self,
    double time,
  ) {
    return _spine_shear_y_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_shear_y_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_shear_y_timeline, ffi.Float)>>(
          'spine_shear_y_timeline_get_curve_value');
  late final _spine_shear_y_timeline_get_curve_value =
      _spine_shear_y_timeline_get_curve_valuePtr.asFunction<double Function(spine_shear_y_timeline, double)>();

  double spine_shear_y_timeline_get_relative_value(
    spine_shear_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_shear_y_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_shear_y_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_shear_y_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_shear_y_timeline_get_relative_value');
  late final _spine_shear_y_timeline_get_relative_value = _spine_shear_y_timeline_get_relative_valuePtr
      .asFunction<double Function(spine_shear_y_timeline, double, double, int, double, double)>();

  double spine_shear_y_timeline_get_absolute_value_1(
    spine_shear_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_shear_y_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_shear_y_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_shear_y_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_shear_y_timeline_get_absolute_value_1');
  late final _spine_shear_y_timeline_get_absolute_value_1 = _spine_shear_y_timeline_get_absolute_value_1Ptr
      .asFunction<double Function(spine_shear_y_timeline, double, double, int, double, double)>();

  double spine_shear_y_timeline_get_absolute_value_2(
    spine_shear_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_shear_y_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_shear_y_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_shear_y_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_shear_y_timeline_get_absolute_value_2');
  late final _spine_shear_y_timeline_get_absolute_value_2 = _spine_shear_y_timeline_get_absolute_value_2Ptr
      .asFunction<double Function(spine_shear_y_timeline, double, double, int, double, double, double)>();

  double spine_shear_y_timeline_get_scale_value(
    spine_shear_y_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_shear_y_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_shear_y_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_shear_y_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_shear_y_timeline_get_scale_value');
  late final _spine_shear_y_timeline_get_scale_value = _spine_shear_y_timeline_get_scale_valuePtr
      .asFunction<double Function(spine_shear_y_timeline, double, double, int, int, double, double)>();

  void spine_shear_y_timeline_set_linear(
    spine_shear_y_timeline self,
    int frame,
  ) {
    return _spine_shear_y_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_shear_y_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_y_timeline, ffi.Size)>>(
          'spine_shear_y_timeline_set_linear');
  late final _spine_shear_y_timeline_set_linear =
      _spine_shear_y_timeline_set_linearPtr.asFunction<void Function(spine_shear_y_timeline, int)>();

  void spine_shear_y_timeline_set_stepped(
    spine_shear_y_timeline self,
    int frame,
  ) {
    return _spine_shear_y_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_shear_y_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_y_timeline, ffi.Size)>>(
          'spine_shear_y_timeline_set_stepped');
  late final _spine_shear_y_timeline_set_stepped =
      _spine_shear_y_timeline_set_steppedPtr.asFunction<void Function(spine_shear_y_timeline, int)>();

  void spine_shear_y_timeline_set_bezier(
    spine_shear_y_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_shear_y_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_shear_y_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_shear_y_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_shear_y_timeline_set_bezier');
  late final _spine_shear_y_timeline_set_bezier = _spine_shear_y_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_shear_y_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_shear_y_timeline_get_bezier_value(
    spine_shear_y_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_shear_y_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_shear_y_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_shear_y_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_shear_y_timeline_get_bezier_value');
  late final _spine_shear_y_timeline_get_bezier_value = _spine_shear_y_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_shear_y_timeline, double, int, int, int)>();

  spine_array_float spine_shear_y_timeline_get_curves(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_curves(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_get_curves');
  late final _spine_shear_y_timeline_get_curves =
      _spine_shear_y_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_shear_y_timeline)>();

  int spine_shear_y_timeline_get_frame_entries(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_get_frame_entries');
  late final _spine_shear_y_timeline_get_frame_entries =
      _spine_shear_y_timeline_get_frame_entriesPtr.asFunction<int Function(spine_shear_y_timeline)>();

  int spine_shear_y_timeline_get_frame_count(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_shear_y_timeline)>>('spine_shear_y_timeline_get_frame_count');
  late final _spine_shear_y_timeline_get_frame_count =
      _spine_shear_y_timeline_get_frame_countPtr.asFunction<int Function(spine_shear_y_timeline)>();

  spine_array_float spine_shear_y_timeline_get_frames(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_frames(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_get_frames');
  late final _spine_shear_y_timeline_get_frames =
      _spine_shear_y_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_shear_y_timeline)>();

  double spine_shear_y_timeline_get_duration(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_duration(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_shear_y_timeline)>>('spine_shear_y_timeline_get_duration');
  late final _spine_shear_y_timeline_get_duration =
      _spine_shear_y_timeline_get_durationPtr.asFunction<double Function(spine_shear_y_timeline)>();

  spine_array_property_id spine_shear_y_timeline_get_property_ids(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_get_property_ids');
  late final _spine_shear_y_timeline_get_property_ids = _spine_shear_y_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_shear_y_timeline)>();

  spine_rtti spine_shear_y_timeline_rtti() {
    return _spine_shear_y_timeline_rtti();
  }

  late final _spine_shear_y_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_shear_y_timeline_rtti');
  late final _spine_shear_y_timeline_rtti = _spine_shear_y_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_skeleton spine_skeleton_create(
    spine_skeleton_data skeletonData,
  ) {
    return _spine_skeleton_create(
      skeletonData,
    );
  }

  late final _spine_skeleton_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton Function(spine_skeleton_data)>>('spine_skeleton_create');
  late final _spine_skeleton_create =
      _spine_skeleton_createPtr.asFunction<spine_skeleton Function(spine_skeleton_data)>();

  void spine_skeleton_dispose(
    spine_skeleton self,
  ) {
    return _spine_skeleton_dispose(
      self,
    );
  }

  late final _spine_skeleton_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>('spine_skeleton_dispose');
  late final _spine_skeleton_dispose = _spine_skeleton_disposePtr.asFunction<void Function(spine_skeleton)>();

  /// Caches information about bones and constraints. Must be called if bones,
  /// constraints or weighted path attachments are added or removed.
  void spine_skeleton_update_cache(
    spine_skeleton self,
  ) {
    return _spine_skeleton_update_cache(
      self,
    );
  }

  late final _spine_skeleton_update_cachePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>('spine_skeleton_update_cache');
  late final _spine_skeleton_update_cache = _spine_skeleton_update_cachePtr.asFunction<void Function(spine_skeleton)>();

  void spine_skeleton_print_update_cache(
    spine_skeleton self,
  ) {
    return _spine_skeleton_print_update_cache(
      self,
    );
  }

  late final _spine_skeleton_print_update_cachePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>('spine_skeleton_print_update_cache');
  late final _spine_skeleton_print_update_cache =
      _spine_skeleton_print_update_cachePtr.asFunction<void Function(spine_skeleton)>();

  void spine_skeleton_constrained(
    spine_skeleton self,
    spine_posed object,
  ) {
    return _spine_skeleton_constrained(
      self,
      object,
    );
  }

  late final _spine_skeleton_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_posed)>>('spine_skeleton_constrained');
  late final _spine_skeleton_constrained =
      _spine_skeleton_constrainedPtr.asFunction<void Function(spine_skeleton, spine_posed)>();

  void spine_skeleton_sort_bone(
    spine_skeleton self,
    spine_bone bone,
  ) {
    return _spine_skeleton_sort_bone(
      self,
      bone,
    );
  }

  late final _spine_skeleton_sort_bonePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_bone)>>('spine_skeleton_sort_bone');
  late final _spine_skeleton_sort_bone =
      _spine_skeleton_sort_bonePtr.asFunction<void Function(spine_skeleton, spine_bone)>();

  void spine_skeleton_sort_reset(
    spine_array_bone bones,
  ) {
    return _spine_skeleton_sort_reset(
      bones,
    );
  }

  late final _spine_skeleton_sort_resetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone)>>('spine_skeleton_sort_reset');
  late final _spine_skeleton_sort_reset = _spine_skeleton_sort_resetPtr.asFunction<void Function(spine_array_bone)>();

  /// Updates the world transform for each bone and applies all constraints.
  ///
  /// See [World
  /// transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms)
  /// in the Spine Runtimes Guide.
  void spine_skeleton_update_world_transform(
    spine_skeleton self,
    int physics,
  ) {
    return _spine_skeleton_update_world_transform(
      self,
      physics,
    );
  }

  late final _spine_skeleton_update_world_transformPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Int32)>>(
          'spine_skeleton_update_world_transform');
  late final _spine_skeleton_update_world_transform =
      _spine_skeleton_update_world_transformPtr.asFunction<void Function(spine_skeleton, int)>();

  /// Sets the bones, constraints, and slots to their setup pose values.
  void spine_skeleton_setup_pose(
    spine_skeleton self,
  ) {
    return _spine_skeleton_setup_pose(
      self,
    );
  }

  late final _spine_skeleton_setup_posePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>('spine_skeleton_setup_pose');
  late final _spine_skeleton_setup_pose = _spine_skeleton_setup_posePtr.asFunction<void Function(spine_skeleton)>();

  /// Sets the bones and constraints to their setup pose values.
  void spine_skeleton_setup_pose_bones(
    spine_skeleton self,
  ) {
    return _spine_skeleton_setup_pose_bones(
      self,
    );
  }

  late final _spine_skeleton_setup_pose_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>('spine_skeleton_setup_pose_bones');
  late final _spine_skeleton_setup_pose_bones =
      _spine_skeleton_setup_pose_bonesPtr.asFunction<void Function(spine_skeleton)>();

  void spine_skeleton_setup_pose_slots(
    spine_skeleton self,
  ) {
    return _spine_skeleton_setup_pose_slots(
      self,
    );
  }

  late final _spine_skeleton_setup_pose_slotsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>('spine_skeleton_setup_pose_slots');
  late final _spine_skeleton_setup_pose_slots =
      _spine_skeleton_setup_pose_slotsPtr.asFunction<void Function(spine_skeleton)>();

  spine_skeleton_data spine_skeleton_get_data(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_data(
      self,
    );
  }

  late final _spine_skeleton_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_data Function(spine_skeleton)>>('spine_skeleton_get_data');
  late final _spine_skeleton_get_data =
      _spine_skeleton_get_dataPtr.asFunction<spine_skeleton_data Function(spine_skeleton)>();

  spine_array_bone spine_skeleton_get_bones(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_bones(
      self,
    );
  }

  late final _spine_skeleton_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_bone Function(spine_skeleton)>>('spine_skeleton_get_bones');
  late final _spine_skeleton_get_bones =
      _spine_skeleton_get_bonesPtr.asFunction<spine_array_bone Function(spine_skeleton)>();

  spine_array_update spine_skeleton_get_update_cache(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_update_cache(
      self,
    );
  }

  late final _spine_skeleton_get_update_cachePtr =
      _lookup<ffi.NativeFunction<spine_array_update Function(spine_skeleton)>>('spine_skeleton_get_update_cache');
  late final _spine_skeleton_get_update_cache =
      _spine_skeleton_get_update_cachePtr.asFunction<spine_array_update Function(spine_skeleton)>();

  spine_bone spine_skeleton_get_root_bone(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_root_bone(
      self,
    );
  }

  late final _spine_skeleton_get_root_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_skeleton)>>('spine_skeleton_get_root_bone');
  late final _spine_skeleton_get_root_bone =
      _spine_skeleton_get_root_bonePtr.asFunction<spine_bone Function(spine_skeleton)>();

  spine_bone spine_skeleton_find_bone(
    spine_skeleton self,
    ffi.Pointer<ffi.Char> boneName,
  ) {
    return _spine_skeleton_find_bone(
      self,
      boneName,
    );
  }

  late final _spine_skeleton_find_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_skeleton, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_find_bone');
  late final _spine_skeleton_find_bone =
      _spine_skeleton_find_bonePtr.asFunction<spine_bone Function(spine_skeleton, ffi.Pointer<ffi.Char>)>();

  spine_array_slot spine_skeleton_get_slots(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_slots(
      self,
    );
  }

  late final _spine_skeleton_get_slotsPtr =
      _lookup<ffi.NativeFunction<spine_array_slot Function(spine_skeleton)>>('spine_skeleton_get_slots');
  late final _spine_skeleton_get_slots =
      _spine_skeleton_get_slotsPtr.asFunction<spine_array_slot Function(spine_skeleton)>();

  spine_slot spine_skeleton_find_slot(
    spine_skeleton self,
    ffi.Pointer<ffi.Char> slotName,
  ) {
    return _spine_skeleton_find_slot(
      self,
      slotName,
    );
  }

  late final _spine_skeleton_find_slotPtr =
      _lookup<ffi.NativeFunction<spine_slot Function(spine_skeleton, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_find_slot');
  late final _spine_skeleton_find_slot =
      _spine_skeleton_find_slotPtr.asFunction<spine_slot Function(spine_skeleton, ffi.Pointer<ffi.Char>)>();

  spine_array_slot spine_skeleton_get_draw_order(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_draw_order(
      self,
    );
  }

  late final _spine_skeleton_get_draw_orderPtr =
      _lookup<ffi.NativeFunction<spine_array_slot Function(spine_skeleton)>>('spine_skeleton_get_draw_order');
  late final _spine_skeleton_get_draw_order =
      _spine_skeleton_get_draw_orderPtr.asFunction<spine_array_slot Function(spine_skeleton)>();

  spine_skin spine_skeleton_get_skin(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_skin(
      self,
    );
  }

  late final _spine_skeleton_get_skinPtr =
      _lookup<ffi.NativeFunction<spine_skin Function(spine_skeleton)>>('spine_skeleton_get_skin');
  late final _spine_skeleton_get_skin = _spine_skeleton_get_skinPtr.asFunction<spine_skin Function(spine_skeleton)>();

  /// Sets a skin by name (see setSkin).
  void spine_skeleton_set_skin_1(
    spine_skeleton self,
    ffi.Pointer<ffi.Char> skinName,
  ) {
    return _spine_skeleton_set_skin_1(
      self,
      skinName,
    );
  }

  late final _spine_skeleton_set_skin_1Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_set_skin_1');
  late final _spine_skeleton_set_skin_1 =
      _spine_skeleton_set_skin_1Ptr.asFunction<void Function(spine_skeleton, ffi.Pointer<ffi.Char>)>();

  /// Attachments from the new skin are attached if the corresponding attachment
  /// from the old skin was attached. If there was no old skin, each slot's setup
  /// mode attachment is attached from the new skin. After changing the skin, the
  /// visible attachments can be reset to those attached in the setup pose by
  /// calling See Skeleton::setSlotsToSetupPose() Also, often
  /// AnimationState::apply(Skeleton & ) is called before the next time the
  /// skeleton is rendered to allow any attachment keys in the current animation(s)
  /// to hide or show attachments from the new skin.
  ///
  /// @param newSkin May be NULL.
  void spine_skeleton_set_skin_2(
    spine_skeleton self,
    spine_skin newSkin,
  ) {
    return _spine_skeleton_set_skin_2(
      self,
      newSkin,
    );
  }

  late final _spine_skeleton_set_skin_2Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_skin)>>('spine_skeleton_set_skin_2');
  late final _spine_skeleton_set_skin_2 =
      _spine_skeleton_set_skin_2Ptr.asFunction<void Function(spine_skeleton, spine_skin)>();

  spine_attachment spine_skeleton_get_attachment_1(
    spine_skeleton self,
    ffi.Pointer<ffi.Char> slotName,
    ffi.Pointer<ffi.Char> attachmentName,
  ) {
    return _spine_skeleton_get_attachment_1(
      self,
      slotName,
      attachmentName,
    );
  }

  late final _spine_skeleton_get_attachment_1Ptr = _lookup<
          ffi.NativeFunction<spine_attachment Function(spine_skeleton, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>>(
      'spine_skeleton_get_attachment_1');
  late final _spine_skeleton_get_attachment_1 = _spine_skeleton_get_attachment_1Ptr
      .asFunction<spine_attachment Function(spine_skeleton, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();

  spine_attachment spine_skeleton_get_attachment_2(
    spine_skeleton self,
    int slotIndex,
    ffi.Pointer<ffi.Char> attachmentName,
  ) {
    return _spine_skeleton_get_attachment_2(
      self,
      slotIndex,
      attachmentName,
    );
  }

  late final _spine_skeleton_get_attachment_2Ptr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_skeleton, ffi.Int, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_get_attachment_2');
  late final _spine_skeleton_get_attachment_2 = _spine_skeleton_get_attachment_2Ptr
      .asFunction<spine_attachment Function(spine_skeleton, int, ffi.Pointer<ffi.Char>)>();

  /// @param attachmentName May be empty.
  void spine_skeleton_set_attachment(
    spine_skeleton self,
    ffi.Pointer<ffi.Char> slotName,
    ffi.Pointer<ffi.Char> attachmentName,
  ) {
    return _spine_skeleton_set_attachment(
      self,
      slotName,
      attachmentName,
    );
  }

  late final _spine_skeleton_set_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_set_attachment');
  late final _spine_skeleton_set_attachment = _spine_skeleton_set_attachmentPtr
      .asFunction<void Function(spine_skeleton, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();

  spine_array_constraint spine_skeleton_get_constraints(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_constraints(
      self,
    );
  }

  late final _spine_skeleton_get_constraintsPtr =
      _lookup<ffi.NativeFunction<spine_array_constraint Function(spine_skeleton)>>('spine_skeleton_get_constraints');
  late final _spine_skeleton_get_constraints =
      _spine_skeleton_get_constraintsPtr.asFunction<spine_array_constraint Function(spine_skeleton)>();

  spine_array_physics_constraint spine_skeleton_get_physics_constraints(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_physics_constraints(
      self,
    );
  }

  late final _spine_skeleton_get_physics_constraintsPtr =
      _lookup<ffi.NativeFunction<spine_array_physics_constraint Function(spine_skeleton)>>(
          'spine_skeleton_get_physics_constraints');
  late final _spine_skeleton_get_physics_constraints =
      _spine_skeleton_get_physics_constraintsPtr.asFunction<spine_array_physics_constraint Function(spine_skeleton)>();

  /// Returns the axis aligned bounding box (AABB) of the region and mesh
  /// attachments for the current pose.
  ///
  /// @param outX The horizontal distance between the skeleton origin and the left side of the AABB.
  /// @param outY The vertical distance between the skeleton origin and the bottom side of the AABB.
  /// @param outWidth The width of the AABB
  /// @param outHeight The height of the AABB.
  void spine_skeleton_get_bounds_1(
    spine_skeleton self,
    ffi.Pointer<ffi.Float> outX,
    ffi.Pointer<ffi.Float> outY,
    ffi.Pointer<ffi.Float> outWidth,
    ffi.Pointer<ffi.Float> outHeight,
  ) {
    return _spine_skeleton_get_bounds_1(
      self,
      outX,
      outY,
      outWidth,
      outHeight,
    );
  }

  late final _spine_skeleton_get_bounds_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>>('spine_skeleton_get_bounds_1');
  late final _spine_skeleton_get_bounds_1 = _spine_skeleton_get_bounds_1Ptr.asFunction<
      void Function(spine_skeleton, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>,
          ffi.Pointer<ffi.Float>)>();

  /// Returns the axis aligned bounding box (AABB) of the region and mesh
  /// attachments for the current pose.
  ///
  /// @param outX The horizontal distance between the skeleton origin and the left side of the AABB.
  /// @param outY The vertical distance between the skeleton origin and the bottom side of the AABB.
  /// @param outWidth The width of the AABB
  /// @param outHeight The height of the AABB.
  /// @param outVertexBuffer Reference to hold an array of floats. This method will assign it with new floats as needed.
  /// @param clipping Pointer to a SkeletonClipping instance or NULL. If a clipper is given, clipping attachments will be taken into account.
  void spine_skeleton_get_bounds_2(
    spine_skeleton self,
    ffi.Pointer<ffi.Float> outX,
    ffi.Pointer<ffi.Float> outY,
    ffi.Pointer<ffi.Float> outWidth,
    ffi.Pointer<ffi.Float> outHeight,
    spine_array_float outVertexBuffer,
    spine_skeleton_clipping clipping,
  ) {
    return _spine_skeleton_get_bounds_2(
      self,
      outX,
      outY,
      outWidth,
      outHeight,
      outVertexBuffer,
      clipping,
    );
  }

  late final _spine_skeleton_get_bounds_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>, spine_array_float, spine_skeleton_clipping)>>('spine_skeleton_get_bounds_2');
  late final _spine_skeleton_get_bounds_2 = _spine_skeleton_get_bounds_2Ptr.asFunction<
      void Function(spine_skeleton, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>,
          ffi.Pointer<ffi.Float>, spine_array_float, spine_skeleton_clipping)>();

  spine_color spine_skeleton_get_color(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_color(
      self,
    );
  }

  late final _spine_skeleton_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_skeleton)>>('spine_skeleton_get_color');
  late final _spine_skeleton_get_color =
      _spine_skeleton_get_colorPtr.asFunction<spine_color Function(spine_skeleton)>();

  void spine_skeleton_set_color_1(
    spine_skeleton self,
    spine_color color,
  ) {
    return _spine_skeleton_set_color_1(
      self,
      color,
    );
  }

  late final _spine_skeleton_set_color_1Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_color)>>('spine_skeleton_set_color_1');
  late final _spine_skeleton_set_color_1 =
      _spine_skeleton_set_color_1Ptr.asFunction<void Function(spine_skeleton, spine_color)>();

  void spine_skeleton_set_color_2(
    spine_skeleton self,
    double r,
    double g,
    double b,
    double a,
  ) {
    return _spine_skeleton_set_color_2(
      self,
      r,
      g,
      b,
      a,
    );
  }

  late final _spine_skeleton_set_color_2Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
          'spine_skeleton_set_color_2');
  late final _spine_skeleton_set_color_2 =
      _spine_skeleton_set_color_2Ptr.asFunction<void Function(spine_skeleton, double, double, double, double)>();

  double spine_skeleton_get_scale_x(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_scale_x(
      self,
    );
  }

  late final _spine_skeleton_get_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>('spine_skeleton_get_scale_x');
  late final _spine_skeleton_get_scale_x = _spine_skeleton_get_scale_xPtr.asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_scale_x(
    spine_skeleton self,
    double inValue,
  ) {
    return _spine_skeleton_set_scale_x(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_set_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>('spine_skeleton_set_scale_x');
  late final _spine_skeleton_set_scale_x =
      _spine_skeleton_set_scale_xPtr.asFunction<void Function(spine_skeleton, double)>();

  double spine_skeleton_get_scale_y(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_scale_y(
      self,
    );
  }

  late final _spine_skeleton_get_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>('spine_skeleton_get_scale_y');
  late final _spine_skeleton_get_scale_y = _spine_skeleton_get_scale_yPtr.asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_scale_y(
    spine_skeleton self,
    double inValue,
  ) {
    return _spine_skeleton_set_scale_y(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_set_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>('spine_skeleton_set_scale_y');
  late final _spine_skeleton_set_scale_y =
      _spine_skeleton_set_scale_yPtr.asFunction<void Function(spine_skeleton, double)>();

  void spine_skeleton_set_scale(
    spine_skeleton self,
    double scaleX,
    double scaleY,
  ) {
    return _spine_skeleton_set_scale(
      self,
      scaleX,
      scaleY,
    );
  }

  late final _spine_skeleton_set_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float, ffi.Float)>>('spine_skeleton_set_scale');
  late final _spine_skeleton_set_scale =
      _spine_skeleton_set_scalePtr.asFunction<void Function(spine_skeleton, double, double)>();

  double spine_skeleton_get_x(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_x(
      self,
    );
  }

  late final _spine_skeleton_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>('spine_skeleton_get_x');
  late final _spine_skeleton_get_x = _spine_skeleton_get_xPtr.asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_x(
    spine_skeleton self,
    double inValue,
  ) {
    return _spine_skeleton_set_x(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_set_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>('spine_skeleton_set_x');
  late final _spine_skeleton_set_x = _spine_skeleton_set_xPtr.asFunction<void Function(spine_skeleton, double)>();

  double spine_skeleton_get_y(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_y(
      self,
    );
  }

  late final _spine_skeleton_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>('spine_skeleton_get_y');
  late final _spine_skeleton_get_y = _spine_skeleton_get_yPtr.asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_y(
    spine_skeleton self,
    double inValue,
  ) {
    return _spine_skeleton_set_y(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_set_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>('spine_skeleton_set_y');
  late final _spine_skeleton_set_y = _spine_skeleton_set_yPtr.asFunction<void Function(spine_skeleton, double)>();

  void spine_skeleton_set_position(
    spine_skeleton self,
    double x,
    double y,
  ) {
    return _spine_skeleton_set_position(
      self,
      x,
      y,
    );
  }

  late final _spine_skeleton_set_positionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float, ffi.Float)>>(
          'spine_skeleton_set_position');
  late final _spine_skeleton_set_position =
      _spine_skeleton_set_positionPtr.asFunction<void Function(spine_skeleton, double, double)>();

  void spine_skeleton_get_position(
    spine_skeleton self,
    ffi.Pointer<ffi.Float> x,
    ffi.Pointer<ffi.Float> y,
  ) {
    return _spine_skeleton_get_position(
      self,
      x,
      y,
    );
  }

  late final _spine_skeleton_get_positionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>)>>(
          'spine_skeleton_get_position');
  late final _spine_skeleton_get_position = _spine_skeleton_get_positionPtr
      .asFunction<void Function(spine_skeleton, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>)>();

  double spine_skeleton_get_wind_x(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_wind_x(
      self,
    );
  }

  late final _spine_skeleton_get_wind_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>('spine_skeleton_get_wind_x');
  late final _spine_skeleton_get_wind_x = _spine_skeleton_get_wind_xPtr.asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_wind_x(
    spine_skeleton self,
    double windX,
  ) {
    return _spine_skeleton_set_wind_x(
      self,
      windX,
    );
  }

  late final _spine_skeleton_set_wind_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>('spine_skeleton_set_wind_x');
  late final _spine_skeleton_set_wind_x =
      _spine_skeleton_set_wind_xPtr.asFunction<void Function(spine_skeleton, double)>();

  double spine_skeleton_get_wind_y(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_wind_y(
      self,
    );
  }

  late final _spine_skeleton_get_wind_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>('spine_skeleton_get_wind_y');
  late final _spine_skeleton_get_wind_y = _spine_skeleton_get_wind_yPtr.asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_wind_y(
    spine_skeleton self,
    double windY,
  ) {
    return _spine_skeleton_set_wind_y(
      self,
      windY,
    );
  }

  late final _spine_skeleton_set_wind_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>('spine_skeleton_set_wind_y');
  late final _spine_skeleton_set_wind_y =
      _spine_skeleton_set_wind_yPtr.asFunction<void Function(spine_skeleton, double)>();

  double spine_skeleton_get_gravity_x(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_gravity_x(
      self,
    );
  }

  late final _spine_skeleton_get_gravity_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>('spine_skeleton_get_gravity_x');
  late final _spine_skeleton_get_gravity_x =
      _spine_skeleton_get_gravity_xPtr.asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_gravity_x(
    spine_skeleton self,
    double gravityX,
  ) {
    return _spine_skeleton_set_gravity_x(
      self,
      gravityX,
    );
  }

  late final _spine_skeleton_set_gravity_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>('spine_skeleton_set_gravity_x');
  late final _spine_skeleton_set_gravity_x =
      _spine_skeleton_set_gravity_xPtr.asFunction<void Function(spine_skeleton, double)>();

  double spine_skeleton_get_gravity_y(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_gravity_y(
      self,
    );
  }

  late final _spine_skeleton_get_gravity_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>('spine_skeleton_get_gravity_y');
  late final _spine_skeleton_get_gravity_y =
      _spine_skeleton_get_gravity_yPtr.asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_gravity_y(
    spine_skeleton self,
    double gravityY,
  ) {
    return _spine_skeleton_set_gravity_y(
      self,
      gravityY,
    );
  }

  late final _spine_skeleton_set_gravity_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>('spine_skeleton_set_gravity_y');
  late final _spine_skeleton_set_gravity_y =
      _spine_skeleton_set_gravity_yPtr.asFunction<void Function(spine_skeleton, double)>();

  /// Rotates the physics constraint so next {
  void spine_skeleton_physics_translate(
    spine_skeleton self,
    double x,
    double y,
  ) {
    return _spine_skeleton_physics_translate(
      self,
      x,
      y,
    );
  }

  late final _spine_skeleton_physics_translatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float, ffi.Float)>>(
          'spine_skeleton_physics_translate');
  late final _spine_skeleton_physics_translate =
      _spine_skeleton_physics_translatePtr.asFunction<void Function(spine_skeleton, double, double)>();

  /// Calls {
  void spine_skeleton_physics_rotate(
    spine_skeleton self,
    double x,
    double y,
    double degrees,
  ) {
    return _spine_skeleton_physics_rotate(
      self,
      x,
      y,
      degrees,
    );
  }

  late final _spine_skeleton_physics_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float, ffi.Float, ffi.Float)>>(
          'spine_skeleton_physics_rotate');
  late final _spine_skeleton_physics_rotate =
      _spine_skeleton_physics_rotatePtr.asFunction<void Function(spine_skeleton, double, double, double)>();

  double spine_skeleton_get_time(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_time(
      self,
    );
  }

  late final _spine_skeleton_get_timePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>('spine_skeleton_get_time');
  late final _spine_skeleton_get_time = _spine_skeleton_get_timePtr.asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_time(
    spine_skeleton self,
    double time,
  ) {
    return _spine_skeleton_set_time(
      self,
      time,
    );
  }

  late final _spine_skeleton_set_timePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>('spine_skeleton_set_time');
  late final _spine_skeleton_set_time = _spine_skeleton_set_timePtr.asFunction<void Function(spine_skeleton, double)>();

  void spine_skeleton_update(
    spine_skeleton self,
    double delta,
  ) {
    return _spine_skeleton_update(
      self,
      delta,
    );
  }

  late final _spine_skeleton_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>('spine_skeleton_update');
  late final _spine_skeleton_update = _spine_skeleton_updatePtr.asFunction<void Function(spine_skeleton, double)>();

  spine_skeleton_binary spine_skeleton_binary_create(
    spine_atlas atlas,
  ) {
    return _spine_skeleton_binary_create(
      atlas,
    );
  }

  late final _spine_skeleton_binary_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_binary Function(spine_atlas)>>('spine_skeleton_binary_create');
  late final _spine_skeleton_binary_create =
      _spine_skeleton_binary_createPtr.asFunction<spine_skeleton_binary Function(spine_atlas)>();

  spine_skeleton_binary spine_skeleton_binary_create2(
    spine_attachment_loader attachmentLoader,
    bool ownsLoader,
  ) {
    return _spine_skeleton_binary_create2(
      attachmentLoader,
      ownsLoader,
    );
  }

  late final _spine_skeleton_binary_create2Ptr =
      _lookup<ffi.NativeFunction<spine_skeleton_binary Function(spine_attachment_loader, ffi.Bool)>>(
          'spine_skeleton_binary_create2');
  late final _spine_skeleton_binary_create2 =
      _spine_skeleton_binary_create2Ptr.asFunction<spine_skeleton_binary Function(spine_attachment_loader, bool)>();

  void spine_skeleton_binary_dispose(
    spine_skeleton_binary self,
  ) {
    return _spine_skeleton_binary_dispose(
      self,
    );
  }

  late final _spine_skeleton_binary_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_binary)>>('spine_skeleton_binary_dispose');
  late final _spine_skeleton_binary_dispose =
      _spine_skeleton_binary_disposePtr.asFunction<void Function(spine_skeleton_binary)>();

  spine_skeleton_data spine_skeleton_binary_read_skeleton_data(
    spine_skeleton_binary self,
    ffi.Pointer<ffi.UnsignedChar> binary,
    int length,
  ) {
    return _spine_skeleton_binary_read_skeleton_data(
      self,
      binary,
      length,
    );
  }

  late final _spine_skeleton_binary_read_skeleton_dataPtr = _lookup<
          ffi
          .NativeFunction<spine_skeleton_data Function(spine_skeleton_binary, ffi.Pointer<ffi.UnsignedChar>, ffi.Int)>>(
      'spine_skeleton_binary_read_skeleton_data');
  late final _spine_skeleton_binary_read_skeleton_data = _spine_skeleton_binary_read_skeleton_dataPtr
      .asFunction<spine_skeleton_data Function(spine_skeleton_binary, ffi.Pointer<ffi.UnsignedChar>, int)>();

  spine_skeleton_data spine_skeleton_binary_read_skeleton_data_file(
    spine_skeleton_binary self,
    ffi.Pointer<ffi.Char> path,
  ) {
    return _spine_skeleton_binary_read_skeleton_data_file(
      self,
      path,
    );
  }

  late final _spine_skeleton_binary_read_skeleton_data_filePtr =
      _lookup<ffi.NativeFunction<spine_skeleton_data Function(spine_skeleton_binary, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_binary_read_skeleton_data_file');
  late final _spine_skeleton_binary_read_skeleton_data_file = _spine_skeleton_binary_read_skeleton_data_filePtr
      .asFunction<spine_skeleton_data Function(spine_skeleton_binary, ffi.Pointer<ffi.Char>)>();

  void spine_skeleton_binary_set_scale(
    spine_skeleton_binary self,
    double scale,
  ) {
    return _spine_skeleton_binary_set_scale(
      self,
      scale,
    );
  }

  late final _spine_skeleton_binary_set_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_binary, ffi.Float)>>(
          'spine_skeleton_binary_set_scale');
  late final _spine_skeleton_binary_set_scale =
      _spine_skeleton_binary_set_scalePtr.asFunction<void Function(spine_skeleton_binary, double)>();

  ffi.Pointer<ffi.Char> spine_skeleton_binary_get_error(
    spine_skeleton_binary self,
  ) {
    return _spine_skeleton_binary_get_error(
      self,
    );
  }

  late final _spine_skeleton_binary_get_errorPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_binary)>>(
          'spine_skeleton_binary_get_error');
  late final _spine_skeleton_binary_get_error =
      _spine_skeleton_binary_get_errorPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_binary)>();

  spine_skeleton_bounds spine_skeleton_bounds_create() {
    return _spine_skeleton_bounds_create();
  }

  late final _spine_skeleton_bounds_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_bounds Function()>>('spine_skeleton_bounds_create');
  late final _spine_skeleton_bounds_create =
      _spine_skeleton_bounds_createPtr.asFunction<spine_skeleton_bounds Function()>();

  void spine_skeleton_bounds_dispose(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_dispose(
      self,
    );
  }

  late final _spine_skeleton_bounds_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_bounds)>>('spine_skeleton_bounds_dispose');
  late final _spine_skeleton_bounds_dispose =
      _spine_skeleton_bounds_disposePtr.asFunction<void Function(spine_skeleton_bounds)>();

  /// Clears any previous polygons, finds all visible bounding box attachments, and
  /// computes the world vertices for each bounding box's polygon.
  ///
  /// @param skeleton The skeleton.
  /// @param updateAabb If true, the axis aligned bounding box containing all the polygons is computed. If false, the SkeletonBounds AABB methods will always return true.
  void spine_skeleton_bounds_update(
    spine_skeleton_bounds self,
    spine_skeleton skeleton,
    bool updateAabb,
  ) {
    return _spine_skeleton_bounds_update(
      self,
      skeleton,
      updateAabb,
    );
  }

  late final _spine_skeleton_bounds_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_bounds, spine_skeleton, ffi.Bool)>>(
          'spine_skeleton_bounds_update');
  late final _spine_skeleton_bounds_update =
      _spine_skeleton_bounds_updatePtr.asFunction<void Function(spine_skeleton_bounds, spine_skeleton, bool)>();

  /// Returns true if the axis aligned bounding box contains the point.
  bool spine_skeleton_bounds_aabb_contains_point(
    spine_skeleton_bounds self,
    double x,
    double y,
  ) {
    return _spine_skeleton_bounds_aabb_contains_point(
      self,
      x,
      y,
    );
  }

  late final _spine_skeleton_bounds_aabb_contains_pointPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_skeleton_bounds, ffi.Float, ffi.Float)>>(
          'spine_skeleton_bounds_aabb_contains_point');
  late final _spine_skeleton_bounds_aabb_contains_point =
      _spine_skeleton_bounds_aabb_contains_pointPtr.asFunction<bool Function(spine_skeleton_bounds, double, double)>();

  /// Returns true if the axis aligned bounding box intersects the line segment.
  bool spine_skeleton_bounds_aabb_intersects_segment(
    spine_skeleton_bounds self,
    double x1,
    double y1,
    double x2,
    double y2,
  ) {
    return _spine_skeleton_bounds_aabb_intersects_segment(
      self,
      x1,
      y1,
      x2,
      y2,
    );
  }

  late final _spine_skeleton_bounds_aabb_intersects_segmentPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_skeleton_bounds, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
          'spine_skeleton_bounds_aabb_intersects_segment');
  late final _spine_skeleton_bounds_aabb_intersects_segment = _spine_skeleton_bounds_aabb_intersects_segmentPtr
      .asFunction<bool Function(spine_skeleton_bounds, double, double, double, double)>();

  /// Returns true if the axis aligned bounding box intersects the axis aligned
  /// bounding box of the specified bounds.
  bool spine_skeleton_bounds_aabb_intersects_skeleton(
    spine_skeleton_bounds self,
    spine_skeleton_bounds bounds,
  ) {
    return _spine_skeleton_bounds_aabb_intersects_skeleton(
      self,
      bounds,
    );
  }

  late final _spine_skeleton_bounds_aabb_intersects_skeletonPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_skeleton_bounds, spine_skeleton_bounds)>>(
          'spine_skeleton_bounds_aabb_intersects_skeleton');
  late final _spine_skeleton_bounds_aabb_intersects_skeleton = _spine_skeleton_bounds_aabb_intersects_skeletonPtr
      .asFunction<bool Function(spine_skeleton_bounds, spine_skeleton_bounds)>();

  /// Returns true if the polygon contains the point.
  bool spine_skeleton_bounds_contains_point_1(
    spine_skeleton_bounds self,
    spine_polygon polygon,
    double x,
    double y,
  ) {
    return _spine_skeleton_bounds_contains_point_1(
      self,
      polygon,
      x,
      y,
    );
  }

  late final _spine_skeleton_bounds_contains_point_1Ptr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_skeleton_bounds, spine_polygon, ffi.Float, ffi.Float)>>(
          'spine_skeleton_bounds_contains_point_1');
  late final _spine_skeleton_bounds_contains_point_1 = _spine_skeleton_bounds_contains_point_1Ptr
      .asFunction<bool Function(spine_skeleton_bounds, spine_polygon, double, double)>();

  spine_bounding_box_attachment spine_skeleton_bounds_contains_point_2(
    spine_skeleton_bounds self,
    double x,
    double y,
  ) {
    return _spine_skeleton_bounds_contains_point_2(
      self,
      x,
      y,
    );
  }

  late final _spine_skeleton_bounds_contains_point_2Ptr =
      _lookup<ffi.NativeFunction<spine_bounding_box_attachment Function(spine_skeleton_bounds, ffi.Float, ffi.Float)>>(
          'spine_skeleton_bounds_contains_point_2');
  late final _spine_skeleton_bounds_contains_point_2 = _spine_skeleton_bounds_contains_point_2Ptr
      .asFunction<spine_bounding_box_attachment Function(spine_skeleton_bounds, double, double)>();

  spine_bounding_box_attachment spine_skeleton_bounds_intersects_segment_1(
    spine_skeleton_bounds self,
    double x1,
    double y1,
    double x2,
    double y2,
  ) {
    return _spine_skeleton_bounds_intersects_segment_1(
      self,
      x1,
      y1,
      x2,
      y2,
    );
  }

  late final _spine_skeleton_bounds_intersects_segment_1Ptr = _lookup<
      ffi.NativeFunction<
          spine_bounding_box_attachment Function(spine_skeleton_bounds, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_skeleton_bounds_intersects_segment_1');
  late final _spine_skeleton_bounds_intersects_segment_1 = _spine_skeleton_bounds_intersects_segment_1Ptr
      .asFunction<spine_bounding_box_attachment Function(spine_skeleton_bounds, double, double, double, double)>();

  /// Returns true if the polygon contains any part of the line segment.
  bool spine_skeleton_bounds_intersects_segment_2(
    spine_skeleton_bounds self,
    spine_polygon polygon,
    double x1,
    double y1,
    double x2,
    double y2,
  ) {
    return _spine_skeleton_bounds_intersects_segment_2(
      self,
      polygon,
      x1,
      y1,
      x2,
      y2,
    );
  }

  late final _spine_skeleton_bounds_intersects_segment_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(spine_skeleton_bounds, spine_polygon, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_skeleton_bounds_intersects_segment_2');
  late final _spine_skeleton_bounds_intersects_segment_2 = _spine_skeleton_bounds_intersects_segment_2Ptr
      .asFunction<bool Function(spine_skeleton_bounds, spine_polygon, double, double, double, double)>();

  spine_polygon spine_skeleton_bounds_get_polygon(
    spine_skeleton_bounds self,
    spine_bounding_box_attachment attachment,
  ) {
    return _spine_skeleton_bounds_get_polygon(
      self,
      attachment,
    );
  }

  late final _spine_skeleton_bounds_get_polygonPtr =
      _lookup<ffi.NativeFunction<spine_polygon Function(spine_skeleton_bounds, spine_bounding_box_attachment)>>(
          'spine_skeleton_bounds_get_polygon');
  late final _spine_skeleton_bounds_get_polygon = _spine_skeleton_bounds_get_polygonPtr
      .asFunction<spine_polygon Function(spine_skeleton_bounds, spine_bounding_box_attachment)>();

  spine_bounding_box_attachment spine_skeleton_bounds_get_bounding_box(
    spine_skeleton_bounds self,
    spine_polygon polygon,
  ) {
    return _spine_skeleton_bounds_get_bounding_box(
      self,
      polygon,
    );
  }

  late final _spine_skeleton_bounds_get_bounding_boxPtr =
      _lookup<ffi.NativeFunction<spine_bounding_box_attachment Function(spine_skeleton_bounds, spine_polygon)>>(
          'spine_skeleton_bounds_get_bounding_box');
  late final _spine_skeleton_bounds_get_bounding_box = _spine_skeleton_bounds_get_bounding_boxPtr
      .asFunction<spine_bounding_box_attachment Function(spine_skeleton_bounds, spine_polygon)>();

  /// Returns all polygons or an empty array. Requires a call to update() first.
  spine_array_polygon spine_skeleton_bounds_get_polygons(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_polygons(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_polygonsPtr =
      _lookup<ffi.NativeFunction<spine_array_polygon Function(spine_skeleton_bounds)>>(
          'spine_skeleton_bounds_get_polygons');
  late final _spine_skeleton_bounds_get_polygons =
      _spine_skeleton_bounds_get_polygonsPtr.asFunction<spine_array_polygon Function(spine_skeleton_bounds)>();

  /// Returns all bounding boxes. Requires a call to update() first.
  spine_array_bounding_box_attachment spine_skeleton_bounds_get_bounding_boxes(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_bounding_boxes(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_bounding_boxesPtr =
      _lookup<ffi.NativeFunction<spine_array_bounding_box_attachment Function(spine_skeleton_bounds)>>(
          'spine_skeleton_bounds_get_bounding_boxes');
  late final _spine_skeleton_bounds_get_bounding_boxes = _spine_skeleton_bounds_get_bounding_boxesPtr
      .asFunction<spine_array_bounding_box_attachment Function(spine_skeleton_bounds)>();

  /// The left edge of the axis aligned bounding box.
  double spine_skeleton_bounds_get_min_x(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_min_x(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_min_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_bounds)>>('spine_skeleton_bounds_get_min_x');
  late final _spine_skeleton_bounds_get_min_x =
      _spine_skeleton_bounds_get_min_xPtr.asFunction<double Function(spine_skeleton_bounds)>();

  /// The bottom edge of the axis aligned bounding box.
  double spine_skeleton_bounds_get_min_y(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_min_y(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_min_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_bounds)>>('spine_skeleton_bounds_get_min_y');
  late final _spine_skeleton_bounds_get_min_y =
      _spine_skeleton_bounds_get_min_yPtr.asFunction<double Function(spine_skeleton_bounds)>();

  /// The right edge of the axis aligned bounding box.
  double spine_skeleton_bounds_get_max_x(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_max_x(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_max_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_bounds)>>('spine_skeleton_bounds_get_max_x');
  late final _spine_skeleton_bounds_get_max_x =
      _spine_skeleton_bounds_get_max_xPtr.asFunction<double Function(spine_skeleton_bounds)>();

  /// The top edge of the axis aligned bounding box.
  double spine_skeleton_bounds_get_max_y(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_max_y(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_max_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_bounds)>>('spine_skeleton_bounds_get_max_y');
  late final _spine_skeleton_bounds_get_max_y =
      _spine_skeleton_bounds_get_max_yPtr.asFunction<double Function(spine_skeleton_bounds)>();

  /// The width of the axis aligned bounding box.
  double spine_skeleton_bounds_get_width(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_width(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_bounds)>>('spine_skeleton_bounds_get_width');
  late final _spine_skeleton_bounds_get_width =
      _spine_skeleton_bounds_get_widthPtr.asFunction<double Function(spine_skeleton_bounds)>();

  /// The height of the axis aligned bounding box.
  double spine_skeleton_bounds_get_height(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_height(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_bounds)>>('spine_skeleton_bounds_get_height');
  late final _spine_skeleton_bounds_get_height =
      _spine_skeleton_bounds_get_heightPtr.asFunction<double Function(spine_skeleton_bounds)>();

  spine_skeleton_clipping spine_skeleton_clipping_create() {
    return _spine_skeleton_clipping_create();
  }

  late final _spine_skeleton_clipping_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_clipping Function()>>('spine_skeleton_clipping_create');
  late final _spine_skeleton_clipping_create =
      _spine_skeleton_clipping_createPtr.asFunction<spine_skeleton_clipping Function()>();

  void spine_skeleton_clipping_dispose(
    spine_skeleton_clipping self,
  ) {
    return _spine_skeleton_clipping_dispose(
      self,
    );
  }

  late final _spine_skeleton_clipping_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_clipping)>>('spine_skeleton_clipping_dispose');
  late final _spine_skeleton_clipping_dispose =
      _spine_skeleton_clipping_disposePtr.asFunction<void Function(spine_skeleton_clipping)>();

  int spine_skeleton_clipping_clip_start(
    spine_skeleton_clipping self,
    spine_skeleton skeleton,
    spine_slot slot,
    spine_clipping_attachment clip,
  ) {
    return _spine_skeleton_clipping_clip_start(
      self,
      skeleton,
      slot,
      clip,
    );
  }

  late final _spine_skeleton_clipping_clip_startPtr = _lookup<
      ffi.NativeFunction<
          ffi.Size Function(spine_skeleton_clipping, spine_skeleton, spine_slot,
              spine_clipping_attachment)>>('spine_skeleton_clipping_clip_start');
  late final _spine_skeleton_clipping_clip_start = _spine_skeleton_clipping_clip_startPtr
      .asFunction<int Function(spine_skeleton_clipping, spine_skeleton, spine_slot, spine_clipping_attachment)>();

  void spine_skeleton_clipping_clip_end_1(
    spine_skeleton_clipping self,
    spine_slot slot,
  ) {
    return _spine_skeleton_clipping_clip_end_1(
      self,
      slot,
    );
  }

  late final _spine_skeleton_clipping_clip_end_1Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_clipping, spine_slot)>>(
          'spine_skeleton_clipping_clip_end_1');
  late final _spine_skeleton_clipping_clip_end_1 =
      _spine_skeleton_clipping_clip_end_1Ptr.asFunction<void Function(spine_skeleton_clipping, spine_slot)>();

  void spine_skeleton_clipping_clip_end_2(
    spine_skeleton_clipping self,
  ) {
    return _spine_skeleton_clipping_clip_end_2(
      self,
    );
  }

  late final _spine_skeleton_clipping_clip_end_2Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_clipping)>>('spine_skeleton_clipping_clip_end_2');
  late final _spine_skeleton_clipping_clip_end_2 =
      _spine_skeleton_clipping_clip_end_2Ptr.asFunction<void Function(spine_skeleton_clipping)>();

  bool spine_skeleton_clipping_clip_triangles_1(
    spine_skeleton_clipping self,
    ffi.Pointer<ffi.Float> vertices,
    ffi.Pointer<ffi.UnsignedShort> triangles,
    int trianglesLength,
  ) {
    return _spine_skeleton_clipping_clip_triangles_1(
      self,
      vertices,
      triangles,
      trianglesLength,
    );
  }

  late final _spine_skeleton_clipping_clip_triangles_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(spine_skeleton_clipping, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.UnsignedShort>,
              ffi.Size)>>('spine_skeleton_clipping_clip_triangles_1');
  late final _spine_skeleton_clipping_clip_triangles_1 = _spine_skeleton_clipping_clip_triangles_1Ptr.asFunction<
      bool Function(spine_skeleton_clipping, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.UnsignedShort>, int)>();

  bool spine_skeleton_clipping_clip_triangles_2(
    spine_skeleton_clipping self,
    ffi.Pointer<ffi.Float> vertices,
    ffi.Pointer<ffi.UnsignedShort> triangles,
    int trianglesLength,
    ffi.Pointer<ffi.Float> uvs,
    int stride,
  ) {
    return _spine_skeleton_clipping_clip_triangles_2(
      self,
      vertices,
      triangles,
      trianglesLength,
      uvs,
      stride,
    );
  }

  late final _spine_skeleton_clipping_clip_triangles_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(spine_skeleton_clipping, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.UnsignedShort>, ffi.Size,
              ffi.Pointer<ffi.Float>, ffi.Size)>>('spine_skeleton_clipping_clip_triangles_2');
  late final _spine_skeleton_clipping_clip_triangles_2 = _spine_skeleton_clipping_clip_triangles_2Ptr.asFunction<
      bool Function(spine_skeleton_clipping, ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.UnsignedShort>, int,
          ffi.Pointer<ffi.Float>, int)>();

  bool spine_skeleton_clipping_clip_triangles_3(
    spine_skeleton_clipping self,
    spine_array_float vertices,
    spine_array_unsigned_short triangles,
    spine_array_float uvs,
    int stride,
  ) {
    return _spine_skeleton_clipping_clip_triangles_3(
      self,
      vertices,
      triangles,
      uvs,
      stride,
    );
  }

  late final _spine_skeleton_clipping_clip_triangles_3Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(spine_skeleton_clipping, spine_array_float, spine_array_unsigned_short, spine_array_float,
              ffi.Size)>>('spine_skeleton_clipping_clip_triangles_3');
  late final _spine_skeleton_clipping_clip_triangles_3 = _spine_skeleton_clipping_clip_triangles_3Ptr.asFunction<
      bool Function(spine_skeleton_clipping, spine_array_float, spine_array_unsigned_short, spine_array_float, int)>();

  bool spine_skeleton_clipping_is_clipping(
    spine_skeleton_clipping self,
  ) {
    return _spine_skeleton_clipping_is_clipping(
      self,
    );
  }

  late final _spine_skeleton_clipping_is_clippingPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_skeleton_clipping)>>('spine_skeleton_clipping_is_clipping');
  late final _spine_skeleton_clipping_is_clipping =
      _spine_skeleton_clipping_is_clippingPtr.asFunction<bool Function(spine_skeleton_clipping)>();

  spine_array_float spine_skeleton_clipping_get_clipped_vertices(
    spine_skeleton_clipping self,
  ) {
    return _spine_skeleton_clipping_get_clipped_vertices(
      self,
    );
  }

  late final _spine_skeleton_clipping_get_clipped_verticesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_skeleton_clipping)>>(
          'spine_skeleton_clipping_get_clipped_vertices');
  late final _spine_skeleton_clipping_get_clipped_vertices = _spine_skeleton_clipping_get_clipped_verticesPtr
      .asFunction<spine_array_float Function(spine_skeleton_clipping)>();

  spine_array_unsigned_short spine_skeleton_clipping_get_clipped_triangles(
    spine_skeleton_clipping self,
  ) {
    return _spine_skeleton_clipping_get_clipped_triangles(
      self,
    );
  }

  late final _spine_skeleton_clipping_get_clipped_trianglesPtr =
      _lookup<ffi.NativeFunction<spine_array_unsigned_short Function(spine_skeleton_clipping)>>(
          'spine_skeleton_clipping_get_clipped_triangles');
  late final _spine_skeleton_clipping_get_clipped_triangles = _spine_skeleton_clipping_get_clipped_trianglesPtr
      .asFunction<spine_array_unsigned_short Function(spine_skeleton_clipping)>();

  spine_array_float spine_skeleton_clipping_get_clipped_u_vs(
    spine_skeleton_clipping self,
  ) {
    return _spine_skeleton_clipping_get_clipped_u_vs(
      self,
    );
  }

  late final _spine_skeleton_clipping_get_clipped_u_vsPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_skeleton_clipping)>>(
          'spine_skeleton_clipping_get_clipped_u_vs');
  late final _spine_skeleton_clipping_get_clipped_u_vs =
      _spine_skeleton_clipping_get_clipped_u_vsPtr.asFunction<spine_array_float Function(spine_skeleton_clipping)>();

  spine_skeleton_json spine_skeleton_json_create(
    spine_atlas atlas,
  ) {
    return _spine_skeleton_json_create(
      atlas,
    );
  }

  late final _spine_skeleton_json_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_json Function(spine_atlas)>>('spine_skeleton_json_create');
  late final _spine_skeleton_json_create =
      _spine_skeleton_json_createPtr.asFunction<spine_skeleton_json Function(spine_atlas)>();

  spine_skeleton_json spine_skeleton_json_create2(
    spine_attachment_loader attachmentLoader,
    bool ownsLoader,
  ) {
    return _spine_skeleton_json_create2(
      attachmentLoader,
      ownsLoader,
    );
  }

  late final _spine_skeleton_json_create2Ptr =
      _lookup<ffi.NativeFunction<spine_skeleton_json Function(spine_attachment_loader, ffi.Bool)>>(
          'spine_skeleton_json_create2');
  late final _spine_skeleton_json_create2 =
      _spine_skeleton_json_create2Ptr.asFunction<spine_skeleton_json Function(spine_attachment_loader, bool)>();

  void spine_skeleton_json_dispose(
    spine_skeleton_json self,
  ) {
    return _spine_skeleton_json_dispose(
      self,
    );
  }

  late final _spine_skeleton_json_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_json)>>('spine_skeleton_json_dispose');
  late final _spine_skeleton_json_dispose =
      _spine_skeleton_json_disposePtr.asFunction<void Function(spine_skeleton_json)>();

  spine_skeleton_data spine_skeleton_json_read_skeleton_data_file(
    spine_skeleton_json self,
    ffi.Pointer<ffi.Char> path,
  ) {
    return _spine_skeleton_json_read_skeleton_data_file(
      self,
      path,
    );
  }

  late final _spine_skeleton_json_read_skeleton_data_filePtr =
      _lookup<ffi.NativeFunction<spine_skeleton_data Function(spine_skeleton_json, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_json_read_skeleton_data_file');
  late final _spine_skeleton_json_read_skeleton_data_file = _spine_skeleton_json_read_skeleton_data_filePtr
      .asFunction<spine_skeleton_data Function(spine_skeleton_json, ffi.Pointer<ffi.Char>)>();

  spine_skeleton_data spine_skeleton_json_read_skeleton_data(
    spine_skeleton_json self,
    ffi.Pointer<ffi.Char> json,
  ) {
    return _spine_skeleton_json_read_skeleton_data(
      self,
      json,
    );
  }

  late final _spine_skeleton_json_read_skeleton_dataPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_data Function(spine_skeleton_json, ffi.Pointer<ffi.Char>)>>(
          'spine_skeleton_json_read_skeleton_data');
  late final _spine_skeleton_json_read_skeleton_data = _spine_skeleton_json_read_skeleton_dataPtr
      .asFunction<spine_skeleton_data Function(spine_skeleton_json, ffi.Pointer<ffi.Char>)>();

  void spine_skeleton_json_set_scale(
    spine_skeleton_json self,
    double scale,
  ) {
    return _spine_skeleton_json_set_scale(
      self,
      scale,
    );
  }

  late final _spine_skeleton_json_set_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_json, ffi.Float)>>('spine_skeleton_json_set_scale');
  late final _spine_skeleton_json_set_scale =
      _spine_skeleton_json_set_scalePtr.asFunction<void Function(spine_skeleton_json, double)>();

  ffi.Pointer<ffi.Char> spine_skeleton_json_get_error(
    spine_skeleton_json self,
  ) {
    return _spine_skeleton_json_get_error(
      self,
    );
  }

  late final _spine_skeleton_json_get_errorPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_json)>>('spine_skeleton_json_get_error');
  late final _spine_skeleton_json_get_error =
      _spine_skeleton_json_get_errorPtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_json)>();

  spine_skeleton_renderer spine_skeleton_renderer_create() {
    return _spine_skeleton_renderer_create();
  }

  late final _spine_skeleton_renderer_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_renderer Function()>>('spine_skeleton_renderer_create');
  late final _spine_skeleton_renderer_create =
      _spine_skeleton_renderer_createPtr.asFunction<spine_skeleton_renderer Function()>();

  void spine_skeleton_renderer_dispose(
    spine_skeleton_renderer self,
  ) {
    return _spine_skeleton_renderer_dispose(
      self,
    );
  }

  late final _spine_skeleton_renderer_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_renderer)>>('spine_skeleton_renderer_dispose');
  late final _spine_skeleton_renderer_dispose =
      _spine_skeleton_renderer_disposePtr.asFunction<void Function(spine_skeleton_renderer)>();

  spine_render_command spine_skeleton_renderer_render(
    spine_skeleton_renderer self,
    spine_skeleton skeleton,
  ) {
    return _spine_skeleton_renderer_render(
      self,
      skeleton,
    );
  }

  late final _spine_skeleton_renderer_renderPtr =
      _lookup<ffi.NativeFunction<spine_render_command Function(spine_skeleton_renderer, spine_skeleton)>>(
          'spine_skeleton_renderer_render');
  late final _spine_skeleton_renderer_render = _spine_skeleton_renderer_renderPtr
      .asFunction<spine_render_command Function(spine_skeleton_renderer, spine_skeleton)>();

  spine_skin spine_skin_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_skin_create(
      name,
    );
  }

  late final _spine_skin_createPtr =
      _lookup<ffi.NativeFunction<spine_skin Function(ffi.Pointer<ffi.Char>)>>('spine_skin_create');
  late final _spine_skin_create = _spine_skin_createPtr.asFunction<spine_skin Function(ffi.Pointer<ffi.Char>)>();

  void spine_skin_dispose(
    spine_skin self,
  ) {
    return _spine_skin_dispose(
      self,
    );
  }

  late final _spine_skin_disposePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin)>>('spine_skin_dispose');
  late final _spine_skin_dispose = _spine_skin_disposePtr.asFunction<void Function(spine_skin)>();

  /// Adds an attachment to the skin for the specified slot index and name. If the
  /// name already exists for the slot, the previous value is replaced.
  void spine_skin_set_attachment(
    spine_skin self,
    int slotIndex,
    ffi.Pointer<ffi.Char> name,
    spine_attachment attachment,
  ) {
    return _spine_skin_set_attachment(
      self,
      slotIndex,
      name,
      attachment,
    );
  }

  late final _spine_skin_set_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin, ffi.Size, ffi.Pointer<ffi.Char>, spine_attachment)>>(
          'spine_skin_set_attachment');
  late final _spine_skin_set_attachment = _spine_skin_set_attachmentPtr
      .asFunction<void Function(spine_skin, int, ffi.Pointer<ffi.Char>, spine_attachment)>();

  spine_attachment spine_skin_get_attachment(
    spine_skin self,
    int slotIndex,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_skin_get_attachment(
      self,
      slotIndex,
      name,
    );
  }

  late final _spine_skin_get_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_skin, ffi.Size, ffi.Pointer<ffi.Char>)>>(
          'spine_skin_get_attachment');
  late final _spine_skin_get_attachment =
      _spine_skin_get_attachmentPtr.asFunction<spine_attachment Function(spine_skin, int, ffi.Pointer<ffi.Char>)>();

  /// Removes the attachment from the skin.
  void spine_skin_remove_attachment(
    spine_skin self,
    int slotIndex,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_skin_remove_attachment(
      self,
      slotIndex,
      name,
    );
  }

  late final _spine_skin_remove_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin, ffi.Size, ffi.Pointer<ffi.Char>)>>(
          'spine_skin_remove_attachment');
  late final _spine_skin_remove_attachment =
      _spine_skin_remove_attachmentPtr.asFunction<void Function(spine_skin, int, ffi.Pointer<ffi.Char>)>();

  /// Finds the attachments for a given slot. The results are added to the passed
  /// array of Attachments.
  ///
  /// @param slotIndex The target slotIndex. To find the slot index, use SkeletonData::findSlot and SlotData::getIndex.
  /// @param attachments Found Attachments will be added to this array.
  void spine_skin_find_attachments_for_slot(
    spine_skin self,
    int slotIndex,
    spine_array_attachment attachments,
  ) {
    return _spine_skin_find_attachments_for_slot(
      self,
      slotIndex,
      attachments,
    );
  }

  late final _spine_skin_find_attachments_for_slotPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin, ffi.Size, spine_array_attachment)>>(
          'spine_skin_find_attachments_for_slot');
  late final _spine_skin_find_attachments_for_slot =
      _spine_skin_find_attachments_for_slotPtr.asFunction<void Function(spine_skin, int, spine_array_attachment)>();

  ffi.Pointer<ffi.Char> spine_skin_get_name(
    spine_skin self,
  ) {
    return _spine_skin_get_name(
      self,
    );
  }

  late final _spine_skin_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skin)>>('spine_skin_get_name');
  late final _spine_skin_get_name = _spine_skin_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_skin)>();

  /// Adds all attachments, bones, and constraints from the specified skin to this
  /// skin.
  void spine_skin_add_skin(
    spine_skin self,
    spine_skin other,
  ) {
    return _spine_skin_add_skin(
      self,
      other,
    );
  }

  late final _spine_skin_add_skinPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin, spine_skin)>>('spine_skin_add_skin');
  late final _spine_skin_add_skin = _spine_skin_add_skinPtr.asFunction<void Function(spine_skin, spine_skin)>();

  /// Adds all attachments, bones, and constraints from the specified skin to this
  /// skin. Attachments are deep copied.
  void spine_skin_copy_skin(
    spine_skin self,
    spine_skin other,
  ) {
    return _spine_skin_copy_skin(
      self,
      other,
    );
  }

  late final _spine_skin_copy_skinPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin, spine_skin)>>('spine_skin_copy_skin');
  late final _spine_skin_copy_skin = _spine_skin_copy_skinPtr.asFunction<void Function(spine_skin, spine_skin)>();

  spine_array_bone_data spine_skin_get_bones(
    spine_skin self,
  ) {
    return _spine_skin_get_bones(
      self,
    );
  }

  late final _spine_skin_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_bone_data Function(spine_skin)>>('spine_skin_get_bones');
  late final _spine_skin_get_bones = _spine_skin_get_bonesPtr.asFunction<spine_array_bone_data Function(spine_skin)>();

  spine_array_constraint_data spine_skin_get_constraints(
    spine_skin self,
  ) {
    return _spine_skin_get_constraints(
      self,
    );
  }

  late final _spine_skin_get_constraintsPtr =
      _lookup<ffi.NativeFunction<spine_array_constraint_data Function(spine_skin)>>('spine_skin_get_constraints');
  late final _spine_skin_get_constraints =
      _spine_skin_get_constraintsPtr.asFunction<spine_array_constraint_data Function(spine_skin)>();

  spine_color spine_skin_get_color(
    spine_skin self,
  ) {
    return _spine_skin_get_color(
      self,
    );
  }

  late final _spine_skin_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_skin)>>('spine_skin_get_color');
  late final _spine_skin_get_color = _spine_skin_get_colorPtr.asFunction<spine_color Function(spine_skin)>();

  spine_slider spine_slider_create(
    spine_slider_data data,
    spine_skeleton skeleton,
  ) {
    return _spine_slider_create(
      data,
      skeleton,
    );
  }

  late final _spine_slider_createPtr =
      _lookup<ffi.NativeFunction<spine_slider Function(spine_slider_data, spine_skeleton)>>('spine_slider_create');
  late final _spine_slider_create =
      _spine_slider_createPtr.asFunction<spine_slider Function(spine_slider_data, spine_skeleton)>();

  void spine_slider_dispose(
    spine_slider self,
  ) {
    return _spine_slider_dispose(
      self,
    );
  }

  late final _spine_slider_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider)>>('spine_slider_dispose');
  late final _spine_slider_dispose = _spine_slider_disposePtr.asFunction<void Function(spine_slider)>();

  spine_rtti spine_slider_get_rtti(
    spine_slider self,
  ) {
    return _spine_slider_get_rtti(
      self,
    );
  }

  late final _spine_slider_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_slider)>>('spine_slider_get_rtti');
  late final _spine_slider_get_rtti = _spine_slider_get_rttiPtr.asFunction<spine_rtti Function(spine_slider)>();

  spine_slider spine_slider_copy(
    spine_slider self,
    spine_skeleton skeleton,
  ) {
    return _spine_slider_copy(
      self,
      skeleton,
    );
  }

  late final _spine_slider_copyPtr =
      _lookup<ffi.NativeFunction<spine_slider Function(spine_slider, spine_skeleton)>>('spine_slider_copy');
  late final _spine_slider_copy =
      _spine_slider_copyPtr.asFunction<spine_slider Function(spine_slider, spine_skeleton)>();

  void spine_slider_update(
    spine_slider self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_slider_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_slider_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider, spine_skeleton, ffi.Int32)>>('spine_slider_update');
  late final _spine_slider_update =
      _spine_slider_updatePtr.asFunction<void Function(spine_slider, spine_skeleton, int)>();

  void spine_slider_sort(
    spine_slider self,
    spine_skeleton skeleton,
  ) {
    return _spine_slider_sort(
      self,
      skeleton,
    );
  }

  late final _spine_slider_sortPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider, spine_skeleton)>>('spine_slider_sort');
  late final _spine_slider_sort = _spine_slider_sortPtr.asFunction<void Function(spine_slider, spine_skeleton)>();

  bool spine_slider_is_source_active(
    spine_slider self,
  ) {
    return _spine_slider_is_source_active(
      self,
    );
  }

  late final _spine_slider_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider)>>('spine_slider_is_source_active');
  late final _spine_slider_is_source_active =
      _spine_slider_is_source_activePtr.asFunction<bool Function(spine_slider)>();

  spine_bone spine_slider_get_bone(
    spine_slider self,
  ) {
    return _spine_slider_get_bone(
      self,
    );
  }

  late final _spine_slider_get_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_slider)>>('spine_slider_get_bone');
  late final _spine_slider_get_bone = _spine_slider_get_bonePtr.asFunction<spine_bone Function(spine_slider)>();

  void spine_slider_set_bone(
    spine_slider self,
    spine_bone bone,
  ) {
    return _spine_slider_set_bone(
      self,
      bone,
    );
  }

  late final _spine_slider_set_bonePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider, spine_bone)>>('spine_slider_set_bone');
  late final _spine_slider_set_bone = _spine_slider_set_bonePtr.asFunction<void Function(spine_slider, spine_bone)>();

  spine_slider_data spine_slider_get_data(
    spine_slider self,
  ) {
    return _spine_slider_get_data(
      self,
    );
  }

  late final _spine_slider_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_slider_data Function(spine_slider)>>('spine_slider_get_data');
  late final _spine_slider_get_data = _spine_slider_get_dataPtr.asFunction<spine_slider_data Function(spine_slider)>();

  spine_slider_pose spine_slider_get_pose(
    spine_slider self,
  ) {
    return _spine_slider_get_pose(
      self,
    );
  }

  late final _spine_slider_get_posePtr =
      _lookup<ffi.NativeFunction<spine_slider_pose Function(spine_slider)>>('spine_slider_get_pose');
  late final _spine_slider_get_pose = _spine_slider_get_posePtr.asFunction<spine_slider_pose Function(spine_slider)>();

  spine_slider_pose spine_slider_get_applied_pose(
    spine_slider self,
  ) {
    return _spine_slider_get_applied_pose(
      self,
    );
  }

  late final _spine_slider_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_slider_pose Function(spine_slider)>>('spine_slider_get_applied_pose');
  late final _spine_slider_get_applied_pose =
      _spine_slider_get_applied_posePtr.asFunction<spine_slider_pose Function(spine_slider)>();

  void spine_slider_reset_constrained(
    spine_slider self,
  ) {
    return _spine_slider_reset_constrained(
      self,
    );
  }

  late final _spine_slider_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider)>>('spine_slider_reset_constrained');
  late final _spine_slider_reset_constrained =
      _spine_slider_reset_constrainedPtr.asFunction<void Function(spine_slider)>();

  void spine_slider_constrained(
    spine_slider self,
  ) {
    return _spine_slider_constrained(
      self,
    );
  }

  late final _spine_slider_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider)>>('spine_slider_constrained');
  late final _spine_slider_constrained = _spine_slider_constrainedPtr.asFunction<void Function(spine_slider)>();

  bool spine_slider_is_pose_equal_to_applied(
    spine_slider self,
  ) {
    return _spine_slider_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_slider_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider)>>('spine_slider_is_pose_equal_to_applied');
  late final _spine_slider_is_pose_equal_to_applied =
      _spine_slider_is_pose_equal_to_appliedPtr.asFunction<bool Function(spine_slider)>();

  bool spine_slider_is_active(
    spine_slider self,
  ) {
    return _spine_slider_is_active(
      self,
    );
  }

  late final _spine_slider_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider)>>('spine_slider_is_active');
  late final _spine_slider_is_active = _spine_slider_is_activePtr.asFunction<bool Function(spine_slider)>();

  void spine_slider_set_active(
    spine_slider self,
    bool active,
  ) {
    return _spine_slider_set_active(
      self,
      active,
    );
  }

  late final _spine_slider_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider, ffi.Bool)>>('spine_slider_set_active');
  late final _spine_slider_set_active = _spine_slider_set_activePtr.asFunction<void Function(spine_slider, bool)>();

  spine_rtti spine_slider_rtti() {
    return _spine_slider_rtti();
  }

  late final _spine_slider_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_slider_rtti');
  late final _spine_slider_rtti = _spine_slider_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_slider_base_dispose(
    spine_slider_base self,
  ) {
    return _spine_slider_base_dispose(
      self,
    );
  }

  late final _spine_slider_base_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_base)>>('spine_slider_base_dispose');
  late final _spine_slider_base_dispose = _spine_slider_base_disposePtr.asFunction<void Function(spine_slider_base)>();

  spine_slider_data spine_slider_base_get_data(
    spine_slider_base self,
  ) {
    return _spine_slider_base_get_data(
      self,
    );
  }

  late final _spine_slider_base_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_slider_data Function(spine_slider_base)>>('spine_slider_base_get_data');
  late final _spine_slider_base_get_data =
      _spine_slider_base_get_dataPtr.asFunction<spine_slider_data Function(spine_slider_base)>();

  spine_slider_pose spine_slider_base_get_pose(
    spine_slider_base self,
  ) {
    return _spine_slider_base_get_pose(
      self,
    );
  }

  late final _spine_slider_base_get_posePtr =
      _lookup<ffi.NativeFunction<spine_slider_pose Function(spine_slider_base)>>('spine_slider_base_get_pose');
  late final _spine_slider_base_get_pose =
      _spine_slider_base_get_posePtr.asFunction<spine_slider_pose Function(spine_slider_base)>();

  spine_slider_pose spine_slider_base_get_applied_pose(
    spine_slider_base self,
  ) {
    return _spine_slider_base_get_applied_pose(
      self,
    );
  }

  late final _spine_slider_base_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_slider_pose Function(spine_slider_base)>>('spine_slider_base_get_applied_pose');
  late final _spine_slider_base_get_applied_pose =
      _spine_slider_base_get_applied_posePtr.asFunction<spine_slider_pose Function(spine_slider_base)>();

  void spine_slider_base_reset_constrained(
    spine_slider_base self,
  ) {
    return _spine_slider_base_reset_constrained(
      self,
    );
  }

  late final _spine_slider_base_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_base)>>('spine_slider_base_reset_constrained');
  late final _spine_slider_base_reset_constrained =
      _spine_slider_base_reset_constrainedPtr.asFunction<void Function(spine_slider_base)>();

  void spine_slider_base_constrained(
    spine_slider_base self,
  ) {
    return _spine_slider_base_constrained(
      self,
    );
  }

  late final _spine_slider_base_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_base)>>('spine_slider_base_constrained');
  late final _spine_slider_base_constrained =
      _spine_slider_base_constrainedPtr.asFunction<void Function(spine_slider_base)>();

  bool spine_slider_base_is_pose_equal_to_applied(
    spine_slider_base self,
  ) {
    return _spine_slider_base_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_slider_base_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider_base)>>('spine_slider_base_is_pose_equal_to_applied');
  late final _spine_slider_base_is_pose_equal_to_applied =
      _spine_slider_base_is_pose_equal_to_appliedPtr.asFunction<bool Function(spine_slider_base)>();

  bool spine_slider_base_is_active(
    spine_slider_base self,
  ) {
    return _spine_slider_base_is_active(
      self,
    );
  }

  late final _spine_slider_base_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider_base)>>('spine_slider_base_is_active');
  late final _spine_slider_base_is_active =
      _spine_slider_base_is_activePtr.asFunction<bool Function(spine_slider_base)>();

  void spine_slider_base_set_active(
    spine_slider_base self,
    bool active,
  ) {
    return _spine_slider_base_set_active(
      self,
      active,
    );
  }

  late final _spine_slider_base_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_base, ffi.Bool)>>('spine_slider_base_set_active');
  late final _spine_slider_base_set_active =
      _spine_slider_base_set_activePtr.asFunction<void Function(spine_slider_base, bool)>();

  spine_rtti spine_slider_base_get_rtti(
    spine_slider_base self,
  ) {
    return _spine_slider_base_get_rtti(
      self,
    );
  }

  late final _spine_slider_base_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_slider_base)>>('spine_slider_base_get_rtti');
  late final _spine_slider_base_get_rtti =
      _spine_slider_base_get_rttiPtr.asFunction<spine_rtti Function(spine_slider_base)>();

  void spine_slider_base_sort(
    spine_slider_base self,
    spine_skeleton skeleton,
  ) {
    return _spine_slider_base_sort(
      self,
      skeleton,
    );
  }

  late final _spine_slider_base_sortPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_base, spine_skeleton)>>('spine_slider_base_sort');
  late final _spine_slider_base_sort =
      _spine_slider_base_sortPtr.asFunction<void Function(spine_slider_base, spine_skeleton)>();

  bool spine_slider_base_is_source_active(
    spine_slider_base self,
  ) {
    return _spine_slider_base_is_source_active(
      self,
    );
  }

  late final _spine_slider_base_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider_base)>>('spine_slider_base_is_source_active');
  late final _spine_slider_base_is_source_active =
      _spine_slider_base_is_source_activePtr.asFunction<bool Function(spine_slider_base)>();

  /// Inherited from Update
  void spine_slider_base_update(
    spine_slider_base self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_slider_base_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_slider_base_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_base, spine_skeleton, ffi.Int32)>>(
          'spine_slider_base_update');
  late final _spine_slider_base_update =
      _spine_slider_base_updatePtr.asFunction<void Function(spine_slider_base, spine_skeleton, int)>();

  spine_rtti spine_slider_base_rtti() {
    return _spine_slider_base_rtti();
  }

  late final _spine_slider_base_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_slider_base_rtti');
  late final _spine_slider_base_rtti = _spine_slider_base_rttiPtr.asFunction<spine_rtti Function()>();

  spine_slider_data spine_slider_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_slider_data_create(
      name,
    );
  }

  late final _spine_slider_data_createPtr =
      _lookup<ffi.NativeFunction<spine_slider_data Function(ffi.Pointer<ffi.Char>)>>('spine_slider_data_create');
  late final _spine_slider_data_create =
      _spine_slider_data_createPtr.asFunction<spine_slider_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_slider_data_dispose(
    spine_slider_data self,
  ) {
    return _spine_slider_data_dispose(
      self,
    );
  }

  late final _spine_slider_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_data)>>('spine_slider_data_dispose');
  late final _spine_slider_data_dispose = _spine_slider_data_disposePtr.asFunction<void Function(spine_slider_data)>();

  spine_rtti spine_slider_data_get_rtti(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_rtti(
      self,
    );
  }

  late final _spine_slider_data_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_slider_data)>>('spine_slider_data_get_rtti');
  late final _spine_slider_data_get_rtti =
      _spine_slider_data_get_rttiPtr.asFunction<spine_rtti Function(spine_slider_data)>();

  /// Creates a slider instance.
  spine_constraint spine_slider_data_create_method(
    spine_slider_data self,
    spine_skeleton skeleton,
  ) {
    return _spine_slider_data_create_method(
      self,
      skeleton,
    );
  }

  late final _spine_slider_data_create_methodPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_slider_data, spine_skeleton)>>(
          'spine_slider_data_create_method');
  late final _spine_slider_data_create_method =
      _spine_slider_data_create_methodPtr.asFunction<spine_constraint Function(spine_slider_data, spine_skeleton)>();

  spine_animation spine_slider_data_get_animation(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_animation(
      self,
    );
  }

  late final _spine_slider_data_get_animationPtr =
      _lookup<ffi.NativeFunction<spine_animation Function(spine_slider_data)>>('spine_slider_data_get_animation');
  late final _spine_slider_data_get_animation =
      _spine_slider_data_get_animationPtr.asFunction<spine_animation Function(spine_slider_data)>();

  void spine_slider_data_set_animation(
    spine_slider_data self,
    spine_animation animation,
  ) {
    return _spine_slider_data_set_animation(
      self,
      animation,
    );
  }

  late final _spine_slider_data_set_animationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_data, spine_animation)>>(
          'spine_slider_data_set_animation');
  late final _spine_slider_data_set_animation =
      _spine_slider_data_set_animationPtr.asFunction<void Function(spine_slider_data, spine_animation)>();

  bool spine_slider_data_get_additive(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_additive(
      self,
    );
  }

  late final _spine_slider_data_get_additivePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider_data)>>('spine_slider_data_get_additive');
  late final _spine_slider_data_get_additive =
      _spine_slider_data_get_additivePtr.asFunction<bool Function(spine_slider_data)>();

  void spine_slider_data_set_additive(
    spine_slider_data self,
    bool additive,
  ) {
    return _spine_slider_data_set_additive(
      self,
      additive,
    );
  }

  late final _spine_slider_data_set_additivePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_data, ffi.Bool)>>('spine_slider_data_set_additive');
  late final _spine_slider_data_set_additive =
      _spine_slider_data_set_additivePtr.asFunction<void Function(spine_slider_data, bool)>();

  bool spine_slider_data_get_loop(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_loop(
      self,
    );
  }

  late final _spine_slider_data_get_loopPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider_data)>>('spine_slider_data_get_loop');
  late final _spine_slider_data_get_loop =
      _spine_slider_data_get_loopPtr.asFunction<bool Function(spine_slider_data)>();

  void spine_slider_data_set_loop(
    spine_slider_data self,
    bool loop,
  ) {
    return _spine_slider_data_set_loop(
      self,
      loop,
    );
  }

  late final _spine_slider_data_set_loopPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_data, ffi.Bool)>>('spine_slider_data_set_loop');
  late final _spine_slider_data_set_loop =
      _spine_slider_data_set_loopPtr.asFunction<void Function(spine_slider_data, bool)>();

  spine_bone_data spine_slider_data_get_bone(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_bone(
      self,
    );
  }

  late final _spine_slider_data_get_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_slider_data)>>('spine_slider_data_get_bone');
  late final _spine_slider_data_get_bone =
      _spine_slider_data_get_bonePtr.asFunction<spine_bone_data Function(spine_slider_data)>();

  void spine_slider_data_set_bone(
    spine_slider_data self,
    spine_bone_data bone,
  ) {
    return _spine_slider_data_set_bone(
      self,
      bone,
    );
  }

  late final _spine_slider_data_set_bonePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_data, spine_bone_data)>>('spine_slider_data_set_bone');
  late final _spine_slider_data_set_bone =
      _spine_slider_data_set_bonePtr.asFunction<void Function(spine_slider_data, spine_bone_data)>();

  spine_from_property spine_slider_data_get_property(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_property(
      self,
    );
  }

  late final _spine_slider_data_get_propertyPtr =
      _lookup<ffi.NativeFunction<spine_from_property Function(spine_slider_data)>>('spine_slider_data_get_property');
  late final _spine_slider_data_get_property =
      _spine_slider_data_get_propertyPtr.asFunction<spine_from_property Function(spine_slider_data)>();

  void spine_slider_data_set_property(
    spine_slider_data self,
    spine_from_property property,
  ) {
    return _spine_slider_data_set_property(
      self,
      property,
    );
  }

  late final _spine_slider_data_set_propertyPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_data, spine_from_property)>>(
          'spine_slider_data_set_property');
  late final _spine_slider_data_set_property =
      _spine_slider_data_set_propertyPtr.asFunction<void Function(spine_slider_data, spine_from_property)>();

  double spine_slider_data_get_scale(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_scale(
      self,
    );
  }

  late final _spine_slider_data_get_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_data)>>('spine_slider_data_get_scale');
  late final _spine_slider_data_get_scale =
      _spine_slider_data_get_scalePtr.asFunction<double Function(spine_slider_data)>();

  void spine_slider_data_set_scale(
    spine_slider_data self,
    double scale,
  ) {
    return _spine_slider_data_set_scale(
      self,
      scale,
    );
  }

  late final _spine_slider_data_set_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_data, ffi.Float)>>('spine_slider_data_set_scale');
  late final _spine_slider_data_set_scale =
      _spine_slider_data_set_scalePtr.asFunction<void Function(spine_slider_data, double)>();

  double spine_slider_data_get_offset(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_offset(
      self,
    );
  }

  late final _spine_slider_data_get_offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_data)>>('spine_slider_data_get_offset');
  late final _spine_slider_data_get_offset =
      _spine_slider_data_get_offsetPtr.asFunction<double Function(spine_slider_data)>();

  void spine_slider_data_set_offset(
    spine_slider_data self,
    double offset,
  ) {
    return _spine_slider_data_set_offset(
      self,
      offset,
    );
  }

  late final _spine_slider_data_set_offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_data, ffi.Float)>>('spine_slider_data_set_offset');
  late final _spine_slider_data_set_offset =
      _spine_slider_data_set_offsetPtr.asFunction<void Function(spine_slider_data, double)>();

  bool spine_slider_data_get_local(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_local(
      self,
    );
  }

  late final _spine_slider_data_get_localPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider_data)>>('spine_slider_data_get_local');
  late final _spine_slider_data_get_local =
      _spine_slider_data_get_localPtr.asFunction<bool Function(spine_slider_data)>();

  void spine_slider_data_set_local(
    spine_slider_data self,
    bool local,
  ) {
    return _spine_slider_data_set_local(
      self,
      local,
    );
  }

  late final _spine_slider_data_set_localPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_data, ffi.Bool)>>('spine_slider_data_set_local');
  late final _spine_slider_data_set_local =
      _spine_slider_data_set_localPtr.asFunction<void Function(spine_slider_data, bool)>();

  /// Resolve ambiguity by forwarding to PosedData's implementation
  ffi.Pointer<ffi.Char> spine_slider_data_get_name(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_name(
      self,
    );
  }

  late final _spine_slider_data_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_slider_data)>>('spine_slider_data_get_name');
  late final _spine_slider_data_get_name =
      _spine_slider_data_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_slider_data)>();

  bool spine_slider_data_get_skin_required(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_skin_required(
      self,
    );
  }

  late final _spine_slider_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider_data)>>('spine_slider_data_get_skin_required');
  late final _spine_slider_data_get_skin_required =
      _spine_slider_data_get_skin_requiredPtr.asFunction<bool Function(spine_slider_data)>();

  spine_slider_pose spine_slider_data_get_setup_pose(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_setup_pose(
      self,
    );
  }

  late final _spine_slider_data_get_setup_posePtr =
      _lookup<ffi.NativeFunction<spine_slider_pose Function(spine_slider_data)>>('spine_slider_data_get_setup_pose');
  late final _spine_slider_data_get_setup_pose =
      _spine_slider_data_get_setup_posePtr.asFunction<spine_slider_pose Function(spine_slider_data)>();

  void spine_slider_data_set_skin_required(
    spine_slider_data self,
    bool skinRequired,
  ) {
    return _spine_slider_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_slider_data_set_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_data, ffi.Bool)>>(
          'spine_slider_data_set_skin_required');
  late final _spine_slider_data_set_skin_required =
      _spine_slider_data_set_skin_requiredPtr.asFunction<void Function(spine_slider_data, bool)>();

  spine_rtti spine_slider_data_rtti() {
    return _spine_slider_data_rtti();
  }

  late final _spine_slider_data_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_slider_data_rtti');
  late final _spine_slider_data_rtti = _spine_slider_data_rttiPtr.asFunction<spine_rtti Function()>();

  spine_slider_mix_timeline spine_slider_mix_timeline_create(
    int frameCount,
    int bezierCount,
    int sliderIndex,
  ) {
    return _spine_slider_mix_timeline_create(
      frameCount,
      bezierCount,
      sliderIndex,
    );
  }

  late final _spine_slider_mix_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_slider_mix_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_slider_mix_timeline_create');
  late final _spine_slider_mix_timeline_create =
      _spine_slider_mix_timeline_createPtr.asFunction<spine_slider_mix_timeline Function(int, int, int)>();

  void spine_slider_mix_timeline_dispose(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_dispose(
      self,
    );
  }

  late final _spine_slider_mix_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_mix_timeline)>>('spine_slider_mix_timeline_dispose');
  late final _spine_slider_mix_timeline_dispose =
      _spine_slider_mix_timeline_disposePtr.asFunction<void Function(spine_slider_mix_timeline)>();

  spine_rtti spine_slider_mix_timeline_get_rtti(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_rtti(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_slider_mix_timeline)>>('spine_slider_mix_timeline_get_rtti');
  late final _spine_slider_mix_timeline_get_rtti =
      _spine_slider_mix_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_slider_mix_timeline)>();

  void spine_slider_mix_timeline_apply(
    spine_slider_mix_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_slider_mix_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_slider_mix_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slider_mix_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event,
              ffi.Float, ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_slider_mix_timeline_apply');
  late final _spine_slider_mix_timeline_apply = _spine_slider_mix_timeline_applyPtr.asFunction<
      void Function(
          spine_slider_mix_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_slider_mix_timeline_get_constraint_index(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_get_constraint_index');
  late final _spine_slider_mix_timeline_get_constraint_index =
      _spine_slider_mix_timeline_get_constraint_indexPtr.asFunction<int Function(spine_slider_mix_timeline)>();

  void spine_slider_mix_timeline_set_constraint_index(
    spine_slider_mix_timeline self,
    int inValue,
  ) {
    return _spine_slider_mix_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_slider_mix_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_mix_timeline, ffi.Int)>>(
          'spine_slider_mix_timeline_set_constraint_index');
  late final _spine_slider_mix_timeline_set_constraint_index =
      _spine_slider_mix_timeline_set_constraint_indexPtr.asFunction<void Function(spine_slider_mix_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_slider_mix_timeline_set_frame(
    spine_slider_mix_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_slider_mix_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_slider_mix_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_mix_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_slider_mix_timeline_set_frame');
  late final _spine_slider_mix_timeline_set_frame = _spine_slider_mix_timeline_set_framePtr
      .asFunction<void Function(spine_slider_mix_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_slider_mix_timeline_get_curve_value(
    spine_slider_mix_timeline self,
    double time,
  ) {
    return _spine_slider_mix_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_slider_mix_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_mix_timeline, ffi.Float)>>(
          'spine_slider_mix_timeline_get_curve_value');
  late final _spine_slider_mix_timeline_get_curve_value =
      _spine_slider_mix_timeline_get_curve_valuePtr.asFunction<double Function(spine_slider_mix_timeline, double)>();

  double spine_slider_mix_timeline_get_relative_value(
    spine_slider_mix_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_slider_mix_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_slider_mix_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_slider_mix_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_slider_mix_timeline_get_relative_value');
  late final _spine_slider_mix_timeline_get_relative_value = _spine_slider_mix_timeline_get_relative_valuePtr
      .asFunction<double Function(spine_slider_mix_timeline, double, double, int, double, double)>();

  double spine_slider_mix_timeline_get_absolute_value_1(
    spine_slider_mix_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_slider_mix_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_slider_mix_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_slider_mix_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_slider_mix_timeline_get_absolute_value_1');
  late final _spine_slider_mix_timeline_get_absolute_value_1 = _spine_slider_mix_timeline_get_absolute_value_1Ptr
      .asFunction<double Function(spine_slider_mix_timeline, double, double, int, double, double)>();

  double spine_slider_mix_timeline_get_absolute_value_2(
    spine_slider_mix_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_slider_mix_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_slider_mix_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_slider_mix_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_slider_mix_timeline_get_absolute_value_2');
  late final _spine_slider_mix_timeline_get_absolute_value_2 = _spine_slider_mix_timeline_get_absolute_value_2Ptr
      .asFunction<double Function(spine_slider_mix_timeline, double, double, int, double, double, double)>();

  double spine_slider_mix_timeline_get_scale_value(
    spine_slider_mix_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_slider_mix_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_slider_mix_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_slider_mix_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_slider_mix_timeline_get_scale_value');
  late final _spine_slider_mix_timeline_get_scale_value = _spine_slider_mix_timeline_get_scale_valuePtr
      .asFunction<double Function(spine_slider_mix_timeline, double, double, int, int, double, double)>();

  void spine_slider_mix_timeline_set_linear(
    spine_slider_mix_timeline self,
    int frame,
  ) {
    return _spine_slider_mix_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_slider_mix_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_mix_timeline, ffi.Size)>>(
          'spine_slider_mix_timeline_set_linear');
  late final _spine_slider_mix_timeline_set_linear =
      _spine_slider_mix_timeline_set_linearPtr.asFunction<void Function(spine_slider_mix_timeline, int)>();

  void spine_slider_mix_timeline_set_stepped(
    spine_slider_mix_timeline self,
    int frame,
  ) {
    return _spine_slider_mix_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_slider_mix_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_mix_timeline, ffi.Size)>>(
          'spine_slider_mix_timeline_set_stepped');
  late final _spine_slider_mix_timeline_set_stepped =
      _spine_slider_mix_timeline_set_steppedPtr.asFunction<void Function(spine_slider_mix_timeline, int)>();

  void spine_slider_mix_timeline_set_bezier(
    spine_slider_mix_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_slider_mix_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_slider_mix_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slider_mix_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_slider_mix_timeline_set_bezier');
  late final _spine_slider_mix_timeline_set_bezier = _spine_slider_mix_timeline_set_bezierPtr.asFunction<
      void Function(spine_slider_mix_timeline, int, int, double, double, double, double, double, double, double, double,
          double)>();

  double spine_slider_mix_timeline_get_bezier_value(
    spine_slider_mix_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_slider_mix_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_slider_mix_timeline_get_bezier_valuePtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_slider_mix_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
      'spine_slider_mix_timeline_get_bezier_value');
  late final _spine_slider_mix_timeline_get_bezier_value = _spine_slider_mix_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_slider_mix_timeline, double, int, int, int)>();

  spine_array_float spine_slider_mix_timeline_get_curves(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_curves(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_get_curves');
  late final _spine_slider_mix_timeline_get_curves =
      _spine_slider_mix_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_slider_mix_timeline)>();

  int spine_slider_mix_timeline_get_frame_entries(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_get_frame_entries');
  late final _spine_slider_mix_timeline_get_frame_entries =
      _spine_slider_mix_timeline_get_frame_entriesPtr.asFunction<int Function(spine_slider_mix_timeline)>();

  int spine_slider_mix_timeline_get_frame_count(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_get_frame_count');
  late final _spine_slider_mix_timeline_get_frame_count =
      _spine_slider_mix_timeline_get_frame_countPtr.asFunction<int Function(spine_slider_mix_timeline)>();

  spine_array_float spine_slider_mix_timeline_get_frames(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_frames(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_get_frames');
  late final _spine_slider_mix_timeline_get_frames =
      _spine_slider_mix_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_slider_mix_timeline)>();

  double spine_slider_mix_timeline_get_duration(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_duration(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_get_duration');
  late final _spine_slider_mix_timeline_get_duration =
      _spine_slider_mix_timeline_get_durationPtr.asFunction<double Function(spine_slider_mix_timeline)>();

  spine_array_property_id spine_slider_mix_timeline_get_property_ids(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_get_property_ids');
  late final _spine_slider_mix_timeline_get_property_ids = _spine_slider_mix_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_slider_mix_timeline)>();

  spine_rtti spine_slider_mix_timeline_rtti() {
    return _spine_slider_mix_timeline_rtti();
  }

  late final _spine_slider_mix_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_slider_mix_timeline_rtti');
  late final _spine_slider_mix_timeline_rtti = _spine_slider_mix_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_slider_pose spine_slider_pose_create() {
    return _spine_slider_pose_create();
  }

  late final _spine_slider_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_slider_pose Function()>>('spine_slider_pose_create');
  late final _spine_slider_pose_create = _spine_slider_pose_createPtr.asFunction<spine_slider_pose Function()>();

  void spine_slider_pose_dispose(
    spine_slider_pose self,
  ) {
    return _spine_slider_pose_dispose(
      self,
    );
  }

  late final _spine_slider_pose_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_pose)>>('spine_slider_pose_dispose');
  late final _spine_slider_pose_dispose = _spine_slider_pose_disposePtr.asFunction<void Function(spine_slider_pose)>();

  void spine_slider_pose_set(
    spine_slider_pose self,
    spine_slider_pose pose,
  ) {
    return _spine_slider_pose_set(
      self,
      pose,
    );
  }

  late final _spine_slider_pose_setPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_pose, spine_slider_pose)>>('spine_slider_pose_set');
  late final _spine_slider_pose_set =
      _spine_slider_pose_setPtr.asFunction<void Function(spine_slider_pose, spine_slider_pose)>();

  double spine_slider_pose_get_time(
    spine_slider_pose self,
  ) {
    return _spine_slider_pose_get_time(
      self,
    );
  }

  late final _spine_slider_pose_get_timePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_pose)>>('spine_slider_pose_get_time');
  late final _spine_slider_pose_get_time =
      _spine_slider_pose_get_timePtr.asFunction<double Function(spine_slider_pose)>();

  void spine_slider_pose_set_time(
    spine_slider_pose self,
    double time,
  ) {
    return _spine_slider_pose_set_time(
      self,
      time,
    );
  }

  late final _spine_slider_pose_set_timePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_pose, ffi.Float)>>('spine_slider_pose_set_time');
  late final _spine_slider_pose_set_time =
      _spine_slider_pose_set_timePtr.asFunction<void Function(spine_slider_pose, double)>();

  double spine_slider_pose_get_mix(
    spine_slider_pose self,
  ) {
    return _spine_slider_pose_get_mix(
      self,
    );
  }

  late final _spine_slider_pose_get_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_pose)>>('spine_slider_pose_get_mix');
  late final _spine_slider_pose_get_mix =
      _spine_slider_pose_get_mixPtr.asFunction<double Function(spine_slider_pose)>();

  void spine_slider_pose_set_mix(
    spine_slider_pose self,
    double mix,
  ) {
    return _spine_slider_pose_set_mix(
      self,
      mix,
    );
  }

  late final _spine_slider_pose_set_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_pose, ffi.Float)>>('spine_slider_pose_set_mix');
  late final _spine_slider_pose_set_mix =
      _spine_slider_pose_set_mixPtr.asFunction<void Function(spine_slider_pose, double)>();

  spine_slider_timeline spine_slider_timeline_create(
    int frameCount,
    int bezierCount,
    int sliderIndex,
  ) {
    return _spine_slider_timeline_create(
      frameCount,
      bezierCount,
      sliderIndex,
    );
  }

  late final _spine_slider_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_slider_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_slider_timeline_create');
  late final _spine_slider_timeline_create =
      _spine_slider_timeline_createPtr.asFunction<spine_slider_timeline Function(int, int, int)>();

  void spine_slider_timeline_dispose(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_dispose(
      self,
    );
  }

  late final _spine_slider_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_timeline)>>('spine_slider_timeline_dispose');
  late final _spine_slider_timeline_dispose =
      _spine_slider_timeline_disposePtr.asFunction<void Function(spine_slider_timeline)>();

  spine_rtti spine_slider_timeline_get_rtti(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_rtti(
      self,
    );
  }

  late final _spine_slider_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_slider_timeline)>>('spine_slider_timeline_get_rtti');
  late final _spine_slider_timeline_get_rtti =
      _spine_slider_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_slider_timeline)>();

  void spine_slider_timeline_apply(
    spine_slider_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_slider_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_slider_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slider_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_slider_timeline_apply');
  late final _spine_slider_timeline_apply = _spine_slider_timeline_applyPtr.asFunction<
      void Function(
          spine_slider_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_slider_timeline_get_constraint_index(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_slider_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_slider_timeline)>>(
          'spine_slider_timeline_get_constraint_index');
  late final _spine_slider_timeline_get_constraint_index =
      _spine_slider_timeline_get_constraint_indexPtr.asFunction<int Function(spine_slider_timeline)>();

  void spine_slider_timeline_set_constraint_index(
    spine_slider_timeline self,
    int inValue,
  ) {
    return _spine_slider_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_slider_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_timeline, ffi.Int)>>(
          'spine_slider_timeline_set_constraint_index');
  late final _spine_slider_timeline_set_constraint_index =
      _spine_slider_timeline_set_constraint_indexPtr.asFunction<void Function(spine_slider_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_slider_timeline_set_frame(
    spine_slider_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_slider_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_slider_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_slider_timeline_set_frame');
  late final _spine_slider_timeline_set_frame =
      _spine_slider_timeline_set_framePtr.asFunction<void Function(spine_slider_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_slider_timeline_get_curve_value(
    spine_slider_timeline self,
    double time,
  ) {
    return _spine_slider_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_slider_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_timeline, ffi.Float)>>(
          'spine_slider_timeline_get_curve_value');
  late final _spine_slider_timeline_get_curve_value =
      _spine_slider_timeline_get_curve_valuePtr.asFunction<double Function(spine_slider_timeline, double)>();

  double spine_slider_timeline_get_relative_value(
    spine_slider_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_slider_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_slider_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_slider_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_slider_timeline_get_relative_value');
  late final _spine_slider_timeline_get_relative_value = _spine_slider_timeline_get_relative_valuePtr
      .asFunction<double Function(spine_slider_timeline, double, double, int, double, double)>();

  double spine_slider_timeline_get_absolute_value_1(
    spine_slider_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_slider_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_slider_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_slider_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_slider_timeline_get_absolute_value_1');
  late final _spine_slider_timeline_get_absolute_value_1 = _spine_slider_timeline_get_absolute_value_1Ptr
      .asFunction<double Function(spine_slider_timeline, double, double, int, double, double)>();

  double spine_slider_timeline_get_absolute_value_2(
    spine_slider_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_slider_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_slider_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_slider_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_slider_timeline_get_absolute_value_2');
  late final _spine_slider_timeline_get_absolute_value_2 = _spine_slider_timeline_get_absolute_value_2Ptr
      .asFunction<double Function(spine_slider_timeline, double, double, int, double, double, double)>();

  double spine_slider_timeline_get_scale_value(
    spine_slider_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_slider_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_slider_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_slider_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_slider_timeline_get_scale_value');
  late final _spine_slider_timeline_get_scale_value = _spine_slider_timeline_get_scale_valuePtr
      .asFunction<double Function(spine_slider_timeline, double, double, int, int, double, double)>();

  void spine_slider_timeline_set_linear(
    spine_slider_timeline self,
    int frame,
  ) {
    return _spine_slider_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_slider_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_timeline, ffi.Size)>>(
          'spine_slider_timeline_set_linear');
  late final _spine_slider_timeline_set_linear =
      _spine_slider_timeline_set_linearPtr.asFunction<void Function(spine_slider_timeline, int)>();

  void spine_slider_timeline_set_stepped(
    spine_slider_timeline self,
    int frame,
  ) {
    return _spine_slider_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_slider_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_timeline, ffi.Size)>>(
          'spine_slider_timeline_set_stepped');
  late final _spine_slider_timeline_set_stepped =
      _spine_slider_timeline_set_steppedPtr.asFunction<void Function(spine_slider_timeline, int)>();

  void spine_slider_timeline_set_bezier(
    spine_slider_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_slider_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_slider_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slider_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_slider_timeline_set_bezier');
  late final _spine_slider_timeline_set_bezier = _spine_slider_timeline_set_bezierPtr.asFunction<
      void Function(
          spine_slider_timeline, int, int, double, double, double, double, double, double, double, double, double)>();

  double spine_slider_timeline_get_bezier_value(
    spine_slider_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_slider_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_slider_timeline_get_bezier_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_slider_timeline_get_bezier_value');
  late final _spine_slider_timeline_get_bezier_value = _spine_slider_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_slider_timeline, double, int, int, int)>();

  spine_array_float spine_slider_timeline_get_curves(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_curves(
      self,
    );
  }

  late final _spine_slider_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_slider_timeline)>>(
          'spine_slider_timeline_get_curves');
  late final _spine_slider_timeline_get_curves =
      _spine_slider_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_slider_timeline)>();

  int spine_slider_timeline_get_frame_entries(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_slider_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_slider_timeline)>>('spine_slider_timeline_get_frame_entries');
  late final _spine_slider_timeline_get_frame_entries =
      _spine_slider_timeline_get_frame_entriesPtr.asFunction<int Function(spine_slider_timeline)>();

  int spine_slider_timeline_get_frame_count(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_slider_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_slider_timeline)>>('spine_slider_timeline_get_frame_count');
  late final _spine_slider_timeline_get_frame_count =
      _spine_slider_timeline_get_frame_countPtr.asFunction<int Function(spine_slider_timeline)>();

  spine_array_float spine_slider_timeline_get_frames(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_frames(
      self,
    );
  }

  late final _spine_slider_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_slider_timeline)>>(
          'spine_slider_timeline_get_frames');
  late final _spine_slider_timeline_get_frames =
      _spine_slider_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_slider_timeline)>();

  double spine_slider_timeline_get_duration(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_duration(
      self,
    );
  }

  late final _spine_slider_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_timeline)>>('spine_slider_timeline_get_duration');
  late final _spine_slider_timeline_get_duration =
      _spine_slider_timeline_get_durationPtr.asFunction<double Function(spine_slider_timeline)>();

  spine_array_property_id spine_slider_timeline_get_property_ids(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_slider_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_slider_timeline)>>(
          'spine_slider_timeline_get_property_ids');
  late final _spine_slider_timeline_get_property_ids =
      _spine_slider_timeline_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_slider_timeline)>();

  spine_rtti spine_slider_timeline_rtti() {
    return _spine_slider_timeline_rtti();
  }

  late final _spine_slider_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_slider_timeline_rtti');
  late final _spine_slider_timeline_rtti = _spine_slider_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_slot spine_slot_create(
    spine_slot_data data,
    spine_skeleton skeleton,
  ) {
    return _spine_slot_create(
      data,
      skeleton,
    );
  }

  late final _spine_slot_createPtr =
      _lookup<ffi.NativeFunction<spine_slot Function(spine_slot_data, spine_skeleton)>>('spine_slot_create');
  late final _spine_slot_create =
      _spine_slot_createPtr.asFunction<spine_slot Function(spine_slot_data, spine_skeleton)>();

  void spine_slot_dispose(
    spine_slot self,
  ) {
    return _spine_slot_dispose(
      self,
    );
  }

  late final _spine_slot_disposePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot)>>('spine_slot_dispose');
  late final _spine_slot_dispose = _spine_slot_disposePtr.asFunction<void Function(spine_slot)>();

  /// The bone this slot belongs to.
  spine_bone spine_slot_get_bone(
    spine_slot self,
  ) {
    return _spine_slot_get_bone(
      self,
    );
  }

  late final _spine_slot_get_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_slot)>>('spine_slot_get_bone');
  late final _spine_slot_get_bone = _spine_slot_get_bonePtr.asFunction<spine_bone Function(spine_slot)>();

  void spine_slot_setup_pose(
    spine_slot self,
  ) {
    return _spine_slot_setup_pose(
      self,
    );
  }

  late final _spine_slot_setup_posePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot)>>('spine_slot_setup_pose');
  late final _spine_slot_setup_pose = _spine_slot_setup_posePtr.asFunction<void Function(spine_slot)>();

  /// The constraint's setup pose data.
  spine_slot_data spine_slot_get_data(
    spine_slot self,
  ) {
    return _spine_slot_get_data(
      self,
    );
  }

  late final _spine_slot_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_slot_data Function(spine_slot)>>('spine_slot_get_data');
  late final _spine_slot_get_data = _spine_slot_get_dataPtr.asFunction<spine_slot_data Function(spine_slot)>();

  spine_slot_pose spine_slot_get_pose(
    spine_slot self,
  ) {
    return _spine_slot_get_pose(
      self,
    );
  }

  late final _spine_slot_get_posePtr =
      _lookup<ffi.NativeFunction<spine_slot_pose Function(spine_slot)>>('spine_slot_get_pose');
  late final _spine_slot_get_pose = _spine_slot_get_posePtr.asFunction<spine_slot_pose Function(spine_slot)>();

  spine_slot_pose spine_slot_get_applied_pose(
    spine_slot self,
  ) {
    return _spine_slot_get_applied_pose(
      self,
    );
  }

  late final _spine_slot_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_slot_pose Function(spine_slot)>>('spine_slot_get_applied_pose');
  late final _spine_slot_get_applied_pose =
      _spine_slot_get_applied_posePtr.asFunction<spine_slot_pose Function(spine_slot)>();

  void spine_slot_reset_constrained(
    spine_slot self,
  ) {
    return _spine_slot_reset_constrained(
      self,
    );
  }

  late final _spine_slot_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot)>>('spine_slot_reset_constrained');
  late final _spine_slot_reset_constrained = _spine_slot_reset_constrainedPtr.asFunction<void Function(spine_slot)>();

  void spine_slot_constrained(
    spine_slot self,
  ) {
    return _spine_slot_constrained(
      self,
    );
  }

  late final _spine_slot_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot)>>('spine_slot_constrained');
  late final _spine_slot_constrained = _spine_slot_constrainedPtr.asFunction<void Function(spine_slot)>();

  bool spine_slot_is_pose_equal_to_applied(
    spine_slot self,
  ) {
    return _spine_slot_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_slot_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slot)>>('spine_slot_is_pose_equal_to_applied');
  late final _spine_slot_is_pose_equal_to_applied =
      _spine_slot_is_pose_equal_to_appliedPtr.asFunction<bool Function(spine_slot)>();

  void spine_slot_curve_timeline_dispose(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_dispose(
      self,
    );
  }

  late final _spine_slot_curve_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_curve_timeline)>>('spine_slot_curve_timeline_dispose');
  late final _spine_slot_curve_timeline_dispose =
      _spine_slot_curve_timeline_disposePtr.asFunction<void Function(spine_slot_curve_timeline)>();

  spine_rtti spine_slot_curve_timeline_get_rtti(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_rtti(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_slot_curve_timeline)>>('spine_slot_curve_timeline_get_rtti');
  late final _spine_slot_curve_timeline_get_rtti =
      _spine_slot_curve_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_slot_curve_timeline)>();

  void spine_slot_curve_timeline_apply(
    spine_slot_curve_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_slot_curve_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_slot_curve_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slot_curve_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event,
              ffi.Float, ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_slot_curve_timeline_apply');
  late final _spine_slot_curve_timeline_apply = _spine_slot_curve_timeline_applyPtr.asFunction<
      void Function(
          spine_slot_curve_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_slot_curve_timeline_get_slot_index(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_get_slot_index');
  late final _spine_slot_curve_timeline_get_slot_index =
      _spine_slot_curve_timeline_get_slot_indexPtr.asFunction<int Function(spine_slot_curve_timeline)>();

  void spine_slot_curve_timeline_set_slot_index(
    spine_slot_curve_timeline self,
    int inValue,
  ) {
    return _spine_slot_curve_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_slot_curve_timeline_set_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_curve_timeline, ffi.Int)>>(
          'spine_slot_curve_timeline_set_slot_index');
  late final _spine_slot_curve_timeline_set_slot_index =
      _spine_slot_curve_timeline_set_slot_indexPtr.asFunction<void Function(spine_slot_curve_timeline, int)>();

  void spine_slot_curve_timeline_set_linear(
    spine_slot_curve_timeline self,
    int frame,
  ) {
    return _spine_slot_curve_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_slot_curve_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_curve_timeline, ffi.Size)>>(
          'spine_slot_curve_timeline_set_linear');
  late final _spine_slot_curve_timeline_set_linear =
      _spine_slot_curve_timeline_set_linearPtr.asFunction<void Function(spine_slot_curve_timeline, int)>();

  void spine_slot_curve_timeline_set_stepped(
    spine_slot_curve_timeline self,
    int frame,
  ) {
    return _spine_slot_curve_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_slot_curve_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_curve_timeline, ffi.Size)>>(
          'spine_slot_curve_timeline_set_stepped');
  late final _spine_slot_curve_timeline_set_stepped =
      _spine_slot_curve_timeline_set_steppedPtr.asFunction<void Function(spine_slot_curve_timeline, int)>();

  void spine_slot_curve_timeline_set_bezier(
    spine_slot_curve_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_slot_curve_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_slot_curve_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slot_curve_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_slot_curve_timeline_set_bezier');
  late final _spine_slot_curve_timeline_set_bezier = _spine_slot_curve_timeline_set_bezierPtr.asFunction<
      void Function(spine_slot_curve_timeline, int, int, double, double, double, double, double, double, double, double,
          double)>();

  double spine_slot_curve_timeline_get_bezier_value(
    spine_slot_curve_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_slot_curve_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_slot_curve_timeline_get_bezier_valuePtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_slot_curve_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
      'spine_slot_curve_timeline_get_bezier_value');
  late final _spine_slot_curve_timeline_get_bezier_value = _spine_slot_curve_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_slot_curve_timeline, double, int, int, int)>();

  spine_array_float spine_slot_curve_timeline_get_curves(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_curves(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_get_curves');
  late final _spine_slot_curve_timeline_get_curves =
      _spine_slot_curve_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_slot_curve_timeline)>();

  int spine_slot_curve_timeline_get_frame_entries(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_get_frame_entries');
  late final _spine_slot_curve_timeline_get_frame_entries =
      _spine_slot_curve_timeline_get_frame_entriesPtr.asFunction<int Function(spine_slot_curve_timeline)>();

  int spine_slot_curve_timeline_get_frame_count(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_get_frame_count');
  late final _spine_slot_curve_timeline_get_frame_count =
      _spine_slot_curve_timeline_get_frame_countPtr.asFunction<int Function(spine_slot_curve_timeline)>();

  spine_array_float spine_slot_curve_timeline_get_frames(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_frames(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_get_frames');
  late final _spine_slot_curve_timeline_get_frames =
      _spine_slot_curve_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_slot_curve_timeline)>();

  double spine_slot_curve_timeline_get_duration(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_duration(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_get_duration');
  late final _spine_slot_curve_timeline_get_duration =
      _spine_slot_curve_timeline_get_durationPtr.asFunction<double Function(spine_slot_curve_timeline)>();

  spine_array_property_id spine_slot_curve_timeline_get_property_ids(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_get_property_ids');
  late final _spine_slot_curve_timeline_get_property_ids = _spine_slot_curve_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_slot_curve_timeline)>();

  spine_rtti spine_slot_curve_timeline_rtti() {
    return _spine_slot_curve_timeline_rtti();
  }

  late final _spine_slot_curve_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_slot_curve_timeline_rtti');
  late final _spine_slot_curve_timeline_rtti = _spine_slot_curve_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_slot_data spine_slot_data_create(
    int index,
    ffi.Pointer<ffi.Char> name,
    spine_bone_data boneData,
  ) {
    return _spine_slot_data_create(
      index,
      name,
      boneData,
    );
  }

  late final _spine_slot_data_createPtr =
      _lookup<ffi.NativeFunction<spine_slot_data Function(ffi.Int, ffi.Pointer<ffi.Char>, spine_bone_data)>>(
          'spine_slot_data_create');
  late final _spine_slot_data_create =
      _spine_slot_data_createPtr.asFunction<spine_slot_data Function(int, ffi.Pointer<ffi.Char>, spine_bone_data)>();

  void spine_slot_data_dispose(
    spine_slot_data self,
  ) {
    return _spine_slot_data_dispose(
      self,
    );
  }

  late final _spine_slot_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data)>>('spine_slot_data_dispose');
  late final _spine_slot_data_dispose = _spine_slot_data_disposePtr.asFunction<void Function(spine_slot_data)>();

  /// The index of the slot in Skeleton::getSlots().
  int spine_slot_data_get_index(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_index(
      self,
    );
  }

  late final _spine_slot_data_get_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_slot_data)>>('spine_slot_data_get_index');
  late final _spine_slot_data_get_index = _spine_slot_data_get_indexPtr.asFunction<int Function(spine_slot_data)>();

  /// The bone this slot belongs to.
  spine_bone_data spine_slot_data_get_bone_data(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_bone_data(
      self,
    );
  }

  late final _spine_slot_data_get_bone_dataPtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_slot_data)>>('spine_slot_data_get_bone_data');
  late final _spine_slot_data_get_bone_data =
      _spine_slot_data_get_bone_dataPtr.asFunction<spine_bone_data Function(spine_slot_data)>();

  void spine_slot_data_set_attachment_name(
    spine_slot_data self,
    ffi.Pointer<ffi.Char> attachmentName,
  ) {
    return _spine_slot_data_set_attachment_name(
      self,
      attachmentName,
    );
  }

  late final _spine_slot_data_set_attachment_namePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Pointer<ffi.Char>)>>(
          'spine_slot_data_set_attachment_name');
  late final _spine_slot_data_set_attachment_name =
      _spine_slot_data_set_attachment_namePtr.asFunction<void Function(spine_slot_data, ffi.Pointer<ffi.Char>)>();

  /// The name of the attachment that is visible for this slot in the setup pose,
  /// or empty if no attachment is visible.
  ffi.Pointer<ffi.Char> spine_slot_data_get_attachment_name(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_attachment_name(
      self,
    );
  }

  late final _spine_slot_data_get_attachment_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_slot_data)>>(
          'spine_slot_data_get_attachment_name');
  late final _spine_slot_data_get_attachment_name =
      _spine_slot_data_get_attachment_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_slot_data)>();

  /// The blend mode for drawing the slot's attachment.
  int spine_slot_data_get_blend_mode(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_blend_mode(
      self,
    );
  }

  late final _spine_slot_data_get_blend_modePtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_slot_data)>>('spine_slot_data_get_blend_mode');
  late final _spine_slot_data_get_blend_mode =
      _spine_slot_data_get_blend_modePtr.asFunction<int Function(spine_slot_data)>();

  void spine_slot_data_set_blend_mode(
    spine_slot_data self,
    int blendMode,
  ) {
    return _spine_slot_data_set_blend_mode(
      self,
      blendMode,
    );
  }

  late final _spine_slot_data_set_blend_modePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Int32)>>('spine_slot_data_set_blend_mode');
  late final _spine_slot_data_set_blend_mode =
      _spine_slot_data_set_blend_modePtr.asFunction<void Function(spine_slot_data, int)>();

  /// False if the slot was hidden in Spine and nonessential data was exported.
  /// Does not affect runtime rendering.
  bool spine_slot_data_get_visible(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_visible(
      self,
    );
  }

  late final _spine_slot_data_get_visiblePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slot_data)>>('spine_slot_data_get_visible');
  late final _spine_slot_data_get_visible =
      _spine_slot_data_get_visiblePtr.asFunction<bool Function(spine_slot_data)>();

  void spine_slot_data_set_visible(
    spine_slot_data self,
    bool visible,
  ) {
    return _spine_slot_data_set_visible(
      self,
      visible,
    );
  }

  late final _spine_slot_data_set_visiblePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Bool)>>('spine_slot_data_set_visible');
  late final _spine_slot_data_set_visible =
      _spine_slot_data_set_visiblePtr.asFunction<void Function(spine_slot_data, bool)>();

  spine_slot_pose spine_slot_data_get_setup_pose(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_setup_pose(
      self,
    );
  }

  late final _spine_slot_data_get_setup_posePtr =
      _lookup<ffi.NativeFunction<spine_slot_pose Function(spine_slot_data)>>('spine_slot_data_get_setup_pose');
  late final _spine_slot_data_get_setup_pose =
      _spine_slot_data_get_setup_posePtr.asFunction<spine_slot_pose Function(spine_slot_data)>();

  /// The constraint's name, which is unique across all constraints in the skeleton
  /// of the same type.
  ffi.Pointer<ffi.Char> spine_slot_data_get_name(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_name(
      self,
    );
  }

  late final _spine_slot_data_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_slot_data)>>('spine_slot_data_get_name');
  late final _spine_slot_data_get_name =
      _spine_slot_data_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_slot_data)>();

  /// When true, Skeleton::updateWorldTransform(Physics) only updates this
  /// constraint if the Skeleton::getSkin() contains this constraint.
  ///
  /// See Skin::getConstraints().
  bool spine_slot_data_get_skin_required(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_skin_required(
      self,
    );
  }

  late final _spine_slot_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slot_data)>>('spine_slot_data_get_skin_required');
  late final _spine_slot_data_get_skin_required =
      _spine_slot_data_get_skin_requiredPtr.asFunction<bool Function(spine_slot_data)>();

  void spine_slot_data_set_skin_required(
    spine_slot_data self,
    bool skinRequired,
  ) {
    return _spine_slot_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_slot_data_set_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Bool)>>('spine_slot_data_set_skin_required');
  late final _spine_slot_data_set_skin_required =
      _spine_slot_data_set_skin_requiredPtr.asFunction<void Function(spine_slot_data, bool)>();

  spine_slot_pose spine_slot_pose_create() {
    return _spine_slot_pose_create();
  }

  late final _spine_slot_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_slot_pose Function()>>('spine_slot_pose_create');
  late final _spine_slot_pose_create = _spine_slot_pose_createPtr.asFunction<spine_slot_pose Function()>();

  void spine_slot_pose_dispose(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_dispose(
      self,
    );
  }

  late final _spine_slot_pose_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_pose)>>('spine_slot_pose_dispose');
  late final _spine_slot_pose_dispose = _spine_slot_pose_disposePtr.asFunction<void Function(spine_slot_pose)>();

  void spine_slot_pose_set(
    spine_slot_pose self,
    spine_slot_pose pose,
  ) {
    return _spine_slot_pose_set(
      self,
      pose,
    );
  }

  late final _spine_slot_pose_setPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_pose, spine_slot_pose)>>('spine_slot_pose_set');
  late final _spine_slot_pose_set =
      _spine_slot_pose_setPtr.asFunction<void Function(spine_slot_pose, spine_slot_pose)>();

  /// The color used to tint the slot's attachment. If getDarkColor() is set, this
  /// is used as the light color for two color tinting.
  spine_color spine_slot_pose_get_color(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_get_color(
      self,
    );
  }

  late final _spine_slot_pose_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_slot_pose)>>('spine_slot_pose_get_color');
  late final _spine_slot_pose_get_color =
      _spine_slot_pose_get_colorPtr.asFunction<spine_color Function(spine_slot_pose)>();

  /// The dark color used to tint the slot's attachment for two color tinting. The
  /// dark color's alpha is not used.
  spine_color spine_slot_pose_get_dark_color(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_get_dark_color(
      self,
    );
  }

  late final _spine_slot_pose_get_dark_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_slot_pose)>>('spine_slot_pose_get_dark_color');
  late final _spine_slot_pose_get_dark_color =
      _spine_slot_pose_get_dark_colorPtr.asFunction<spine_color Function(spine_slot_pose)>();

  /// Returns true if this slot has a dark color.
  bool spine_slot_pose_has_dark_color(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_has_dark_color(
      self,
    );
  }

  late final _spine_slot_pose_has_dark_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slot_pose)>>('spine_slot_pose_has_dark_color');
  late final _spine_slot_pose_has_dark_color =
      _spine_slot_pose_has_dark_colorPtr.asFunction<bool Function(spine_slot_pose)>();

  void spine_slot_pose_set_has_dark_color(
    spine_slot_pose self,
    bool hasDarkColor,
  ) {
    return _spine_slot_pose_set_has_dark_color(
      self,
      hasDarkColor,
    );
  }

  late final _spine_slot_pose_set_has_dark_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_pose, ffi.Bool)>>('spine_slot_pose_set_has_dark_color');
  late final _spine_slot_pose_set_has_dark_color =
      _spine_slot_pose_set_has_dark_colorPtr.asFunction<void Function(spine_slot_pose, bool)>();

  spine_attachment spine_slot_pose_get_attachment(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_get_attachment(
      self,
    );
  }

  late final _spine_slot_pose_get_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_slot_pose)>>('spine_slot_pose_get_attachment');
  late final _spine_slot_pose_get_attachment =
      _spine_slot_pose_get_attachmentPtr.asFunction<spine_attachment Function(spine_slot_pose)>();

  /// Sets the slot's attachment and, if the attachment changed, resets
  /// sequenceIndex and clears the deform. The deform is not cleared if the old
  /// attachment has the same VertexAttachment::getTimelineAttachment() as the
  /// specified attachment.
  void spine_slot_pose_set_attachment(
    spine_slot_pose self,
    spine_attachment attachment,
  ) {
    return _spine_slot_pose_set_attachment(
      self,
      attachment,
    );
  }

  late final _spine_slot_pose_set_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_pose, spine_attachment)>>(
          'spine_slot_pose_set_attachment');
  late final _spine_slot_pose_set_attachment =
      _spine_slot_pose_set_attachmentPtr.asFunction<void Function(spine_slot_pose, spine_attachment)>();

  /// The index of the texture region to display when the slot's attachment has a
  /// Sequence. -1 represents the Sequence::getSetupIndex().
  int spine_slot_pose_get_sequence_index(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_get_sequence_index(
      self,
    );
  }

  late final _spine_slot_pose_get_sequence_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_slot_pose)>>('spine_slot_pose_get_sequence_index');
  late final _spine_slot_pose_get_sequence_index =
      _spine_slot_pose_get_sequence_indexPtr.asFunction<int Function(spine_slot_pose)>();

  void spine_slot_pose_set_sequence_index(
    spine_slot_pose self,
    int sequenceIndex,
  ) {
    return _spine_slot_pose_set_sequence_index(
      self,
      sequenceIndex,
    );
  }

  late final _spine_slot_pose_set_sequence_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_pose, ffi.Int)>>('spine_slot_pose_set_sequence_index');
  late final _spine_slot_pose_set_sequence_index =
      _spine_slot_pose_set_sequence_indexPtr.asFunction<void Function(spine_slot_pose, int)>();

  /// Values to deform the slot's attachment. For an unweighted mesh, the entries
  /// are local positions for each vertex. For a weighted mesh, the entries are an
  /// offset for each vertex which will be added to the mesh's local vertex
  /// positions.
  ///
  /// See VertexAttachment::computeWorldVertices() and DeformTimeline.
  spine_array_float spine_slot_pose_get_deform(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_get_deform(
      self,
    );
  }

  late final _spine_slot_pose_get_deformPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_slot_pose)>>('spine_slot_pose_get_deform');
  late final _spine_slot_pose_get_deform =
      _spine_slot_pose_get_deformPtr.asFunction<spine_array_float Function(spine_slot_pose)>();

  void spine_slot_timeline_dispose(
    spine_slot_timeline self,
  ) {
    return _spine_slot_timeline_dispose(
      self,
    );
  }

  late final _spine_slot_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_timeline)>>('spine_slot_timeline_dispose');
  late final _spine_slot_timeline_dispose =
      _spine_slot_timeline_disposePtr.asFunction<void Function(spine_slot_timeline)>();

  spine_rtti spine_slot_timeline_get_rtti(
    spine_slot_timeline self,
  ) {
    return _spine_slot_timeline_get_rtti(
      self,
    );
  }

  late final _spine_slot_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_slot_timeline)>>('spine_slot_timeline_get_rtti');
  late final _spine_slot_timeline_get_rtti =
      _spine_slot_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_slot_timeline)>();

  /// The index of the slot in Skeleton::getSlots() that will be changed when this
  /// timeline is applied.
  int spine_slot_timeline_get_slot_index(
    spine_slot_timeline self,
  ) {
    return _spine_slot_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_slot_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_slot_timeline)>>('spine_slot_timeline_get_slot_index');
  late final _spine_slot_timeline_get_slot_index =
      _spine_slot_timeline_get_slot_indexPtr.asFunction<int Function(spine_slot_timeline)>();

  void spine_slot_timeline_set_slot_index(
    spine_slot_timeline self,
    int inValue,
  ) {
    return _spine_slot_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_slot_timeline_set_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_timeline, ffi.Int)>>(
          'spine_slot_timeline_set_slot_index');
  late final _spine_slot_timeline_set_slot_index =
      _spine_slot_timeline_set_slot_indexPtr.asFunction<void Function(spine_slot_timeline, int)>();

  spine_rtti spine_slot_timeline_rtti() {
    return _spine_slot_timeline_rtti();
  }

  late final _spine_slot_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_slot_timeline_rtti');
  late final _spine_slot_timeline_rtti = _spine_slot_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_texture_region spine_texture_region_create() {
    return _spine_texture_region_create();
  }

  late final _spine_texture_region_createPtr =
      _lookup<ffi.NativeFunction<spine_texture_region Function()>>('spine_texture_region_create');
  late final _spine_texture_region_create =
      _spine_texture_region_createPtr.asFunction<spine_texture_region Function()>();

  void spine_texture_region_dispose(
    spine_texture_region self,
  ) {
    return _spine_texture_region_dispose(
      self,
    );
  }

  late final _spine_texture_region_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region)>>('spine_texture_region_dispose');
  late final _spine_texture_region_dispose =
      _spine_texture_region_disposePtr.asFunction<void Function(spine_texture_region)>();

  spine_rtti spine_texture_region_get_rtti(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_rtti(
      self,
    );
  }

  late final _spine_texture_region_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_texture_region)>>('spine_texture_region_get_rtti');
  late final _spine_texture_region_get_rtti =
      _spine_texture_region_get_rttiPtr.asFunction<spine_rtti Function(spine_texture_region)>();

  double spine_texture_region_get_u(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_u(
      self,
    );
  }

  late final _spine_texture_region_get_uPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>('spine_texture_region_get_u');
  late final _spine_texture_region_get_u =
      _spine_texture_region_get_uPtr.asFunction<double Function(spine_texture_region)>();

  void spine_texture_region_set_u(
    spine_texture_region self,
    double value,
  ) {
    return _spine_texture_region_set_u(
      self,
      value,
    );
  }

  late final _spine_texture_region_set_uPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>('spine_texture_region_set_u');
  late final _spine_texture_region_set_u =
      _spine_texture_region_set_uPtr.asFunction<void Function(spine_texture_region, double)>();

  double spine_texture_region_get_v(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_v(
      self,
    );
  }

  late final _spine_texture_region_get_vPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>('spine_texture_region_get_v');
  late final _spine_texture_region_get_v =
      _spine_texture_region_get_vPtr.asFunction<double Function(spine_texture_region)>();

  void spine_texture_region_set_v(
    spine_texture_region self,
    double value,
  ) {
    return _spine_texture_region_set_v(
      self,
      value,
    );
  }

  late final _spine_texture_region_set_vPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>('spine_texture_region_set_v');
  late final _spine_texture_region_set_v =
      _spine_texture_region_set_vPtr.asFunction<void Function(spine_texture_region, double)>();

  double spine_texture_region_get_u2(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_u2(
      self,
    );
  }

  late final _spine_texture_region_get_u2Ptr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>('spine_texture_region_get_u2');
  late final _spine_texture_region_get_u2 =
      _spine_texture_region_get_u2Ptr.asFunction<double Function(spine_texture_region)>();

  void spine_texture_region_set_u2(
    spine_texture_region self,
    double value,
  ) {
    return _spine_texture_region_set_u2(
      self,
      value,
    );
  }

  late final _spine_texture_region_set_u2Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>('spine_texture_region_set_u2');
  late final _spine_texture_region_set_u2 =
      _spine_texture_region_set_u2Ptr.asFunction<void Function(spine_texture_region, double)>();

  double spine_texture_region_get_v2(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_v2(
      self,
    );
  }

  late final _spine_texture_region_get_v2Ptr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>('spine_texture_region_get_v2');
  late final _spine_texture_region_get_v2 =
      _spine_texture_region_get_v2Ptr.asFunction<double Function(spine_texture_region)>();

  void spine_texture_region_set_v2(
    spine_texture_region self,
    double value,
  ) {
    return _spine_texture_region_set_v2(
      self,
      value,
    );
  }

  late final _spine_texture_region_set_v2Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>('spine_texture_region_set_v2');
  late final _spine_texture_region_set_v2 =
      _spine_texture_region_set_v2Ptr.asFunction<void Function(spine_texture_region, double)>();

  int spine_texture_region_get_region_width(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_region_width(
      self,
    );
  }

  late final _spine_texture_region_get_region_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_texture_region)>>('spine_texture_region_get_region_width');
  late final _spine_texture_region_get_region_width =
      _spine_texture_region_get_region_widthPtr.asFunction<int Function(spine_texture_region)>();

  void spine_texture_region_set_region_width(
    spine_texture_region self,
    int value,
  ) {
    return _spine_texture_region_set_region_width(
      self,
      value,
    );
  }

  late final _spine_texture_region_set_region_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int)>>(
          'spine_texture_region_set_region_width');
  late final _spine_texture_region_set_region_width =
      _spine_texture_region_set_region_widthPtr.asFunction<void Function(spine_texture_region, int)>();

  int spine_texture_region_get_region_height(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_region_height(
      self,
    );
  }

  late final _spine_texture_region_get_region_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_texture_region)>>('spine_texture_region_get_region_height');
  late final _spine_texture_region_get_region_height =
      _spine_texture_region_get_region_heightPtr.asFunction<int Function(spine_texture_region)>();

  void spine_texture_region_set_region_height(
    spine_texture_region self,
    int value,
  ) {
    return _spine_texture_region_set_region_height(
      self,
      value,
    );
  }

  late final _spine_texture_region_set_region_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int)>>(
          'spine_texture_region_set_region_height');
  late final _spine_texture_region_set_region_height =
      _spine_texture_region_set_region_heightPtr.asFunction<void Function(spine_texture_region, int)>();

  ffi.Pointer<ffi.Void> spine_texture_region_get_renderer_object(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_renderer_object(
      self,
    );
  }

  late final _spine_texture_region_get_renderer_objectPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(spine_texture_region)>>(
          'spine_texture_region_get_renderer_object');
  late final _spine_texture_region_get_renderer_object =
      _spine_texture_region_get_renderer_objectPtr.asFunction<ffi.Pointer<ffi.Void> Function(spine_texture_region)>();

  void spine_texture_region_set_renderer_object(
    spine_texture_region self,
    ffi.Pointer<ffi.Void> value,
  ) {
    return _spine_texture_region_set_renderer_object(
      self,
      value,
    );
  }

  late final _spine_texture_region_set_renderer_objectPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Pointer<ffi.Void>)>>(
          'spine_texture_region_set_renderer_object');
  late final _spine_texture_region_set_renderer_object = _spine_texture_region_set_renderer_objectPtr
      .asFunction<void Function(spine_texture_region, ffi.Pointer<ffi.Void>)>();

  spine_rtti spine_texture_region_rtti() {
    return _spine_texture_region_rtti();
  }

  late final _spine_texture_region_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_texture_region_rtti');
  late final _spine_texture_region_rtti = _spine_texture_region_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_timeline_dispose(
    spine_timeline self,
  ) {
    return _spine_timeline_dispose(
      self,
    );
  }

  late final _spine_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_timeline)>>('spine_timeline_dispose');
  late final _spine_timeline_dispose = _spine_timeline_disposePtr.asFunction<void Function(spine_timeline)>();

  spine_rtti spine_timeline_get_rtti(
    spine_timeline self,
  ) {
    return _spine_timeline_get_rtti(
      self,
    );
  }

  late final _spine_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_timeline)>>('spine_timeline_get_rtti');
  late final _spine_timeline_get_rtti = _spine_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_timeline)>();

  /// Sets the value(s) for the specified time.
  ///
  /// @param skeleton The skeleton the timeline is being applied to. This provides access to the bones, slots, and other skeleton components the timeline may change.
  /// @param lastTime lastTime The time this timeline was last applied. Timelines such as EventTimeline trigger only at specific times rather than every frame. In that case, the timeline triggers everything between lastTime (exclusive) and time (inclusive).
  /// @param time The time within the animation. Most timelines find the key before and the key after this time so they can interpolate between the keys.
  /// @param events If any events are fired, they are added to this array. Can be NULL to ignore firing events or if the timeline does not fire events. May be NULL.
  /// @param alpha alpha 0 applies the current or setup pose value (depending on pose parameter). 1 applies the timeline value. Between 0 and 1 applies a value between the current or setup pose and the timeline value. By adjusting alpha over time, an animation can be mixed in or out. alpha can also be useful to apply animations on top of each other (layered).
  /// @param blend Controls how mixing is applied when alpha is than 1.
  /// @param direction Indicates whether the timeline is mixing in or out. Used by timelines which perform instant transitions such as DrawOrderTimeline and AttachmentTimeline.
  /// @param appliedPose True to modify the applied pose.
  void spine_timeline_apply(
    spine_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event, ffi.Float,
              ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_timeline_apply');
  late final _spine_timeline_apply = _spine_timeline_applyPtr.asFunction<
      void Function(spine_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_timeline_get_frame_entries(
    spine_timeline self,
  ) {
    return _spine_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_timeline)>>('spine_timeline_get_frame_entries');
  late final _spine_timeline_get_frame_entries =
      _spine_timeline_get_frame_entriesPtr.asFunction<int Function(spine_timeline)>();

  int spine_timeline_get_frame_count(
    spine_timeline self,
  ) {
    return _spine_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_timeline)>>('spine_timeline_get_frame_count');
  late final _spine_timeline_get_frame_count =
      _spine_timeline_get_frame_countPtr.asFunction<int Function(spine_timeline)>();

  spine_array_float spine_timeline_get_frames(
    spine_timeline self,
  ) {
    return _spine_timeline_get_frames(
      self,
    );
  }

  late final _spine_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_timeline)>>('spine_timeline_get_frames');
  late final _spine_timeline_get_frames =
      _spine_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_timeline)>();

  double spine_timeline_get_duration(
    spine_timeline self,
  ) {
    return _spine_timeline_get_duration(
      self,
    );
  }

  late final _spine_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_timeline)>>('spine_timeline_get_duration');
  late final _spine_timeline_get_duration =
      _spine_timeline_get_durationPtr.asFunction<double Function(spine_timeline)>();

  spine_array_property_id spine_timeline_get_property_ids(
    spine_timeline self,
  ) {
    return _spine_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_timeline)>>('spine_timeline_get_property_ids');
  late final _spine_timeline_get_property_ids =
      _spine_timeline_get_property_idsPtr.asFunction<spine_array_property_id Function(spine_timeline)>();

  spine_rtti spine_timeline_rtti() {
    return _spine_timeline_rtti();
  }

  late final _spine_timeline_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_timeline_rtti');
  late final _spine_timeline_rtti = _spine_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_to_property_dispose(
    spine_to_property self,
  ) {
    return _spine_to_property_dispose(
      self,
    );
  }

  late final _spine_to_property_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_property)>>('spine_to_property_dispose');
  late final _spine_to_property_dispose = _spine_to_property_disposePtr.asFunction<void Function(spine_to_property)>();

  spine_rtti spine_to_property_get_rtti(
    spine_to_property self,
  ) {
    return _spine_to_property_get_rtti(
      self,
    );
  }

  late final _spine_to_property_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_property)>>('spine_to_property_get_rtti');
  late final _spine_to_property_get_rtti =
      _spine_to_property_get_rttiPtr.asFunction<spine_rtti Function(spine_to_property)>();

  /// Reads the mix for this property from the specified pose.
  double spine_to_property_mix(
    spine_to_property self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_property_mix(
      self,
      pose,
    );
  }

  late final _spine_to_property_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_to_property, spine_transform_constraint_pose)>>(
          'spine_to_property_mix');
  late final _spine_to_property_mix =
      _spine_to_property_mixPtr.asFunction<double Function(spine_to_property, spine_transform_constraint_pose)>();

  /// Applies the value to this property.
  void spine_to_property_apply(
    spine_to_property self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_property_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_property_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_to_property, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose,
              ffi.Float, ffi.Bool, ffi.Bool)>>('spine_to_property_apply');
  late final _spine_to_property_apply = _spine_to_property_applyPtr.asFunction<
      void Function(
          spine_to_property, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose, double, bool, bool)>();

  spine_rtti spine_to_property_rtti() {
    return _spine_to_property_rtti();
  }

  late final _spine_to_property_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_to_property_rtti');
  late final _spine_to_property_rtti = _spine_to_property_rttiPtr.asFunction<spine_rtti Function()>();

  double spine_to_property_get__offset(
    spine_to_property self,
  ) {
    return _spine_to_property_get__offset(
      self,
    );
  }

  late final _spine_to_property_get__offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_to_property)>>('spine_to_property_get__offset');
  late final _spine_to_property_get__offset =
      _spine_to_property_get__offsetPtr.asFunction<double Function(spine_to_property)>();

  void spine_to_property_set__offset(
    spine_to_property self,
    double value,
  ) {
    return _spine_to_property_set__offset(
      self,
      value,
    );
  }

  late final _spine_to_property_set__offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_property, ffi.Float)>>('spine_to_property_set__offset');
  late final _spine_to_property_set__offset =
      _spine_to_property_set__offsetPtr.asFunction<void Function(spine_to_property, double)>();

  double spine_to_property_get__max(
    spine_to_property self,
  ) {
    return _spine_to_property_get__max(
      self,
    );
  }

  late final _spine_to_property_get__maxPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_to_property)>>('spine_to_property_get__max');
  late final _spine_to_property_get__max =
      _spine_to_property_get__maxPtr.asFunction<double Function(spine_to_property)>();

  void spine_to_property_set__max(
    spine_to_property self,
    double value,
  ) {
    return _spine_to_property_set__max(
      self,
      value,
    );
  }

  late final _spine_to_property_set__maxPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_property, ffi.Float)>>('spine_to_property_set__max');
  late final _spine_to_property_set__max =
      _spine_to_property_set__maxPtr.asFunction<void Function(spine_to_property, double)>();

  double spine_to_property_get__scale(
    spine_to_property self,
  ) {
    return _spine_to_property_get__scale(
      self,
    );
  }

  late final _spine_to_property_get__scalePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_to_property)>>('spine_to_property_get__scale');
  late final _spine_to_property_get__scale =
      _spine_to_property_get__scalePtr.asFunction<double Function(spine_to_property)>();

  void spine_to_property_set__scale(
    spine_to_property self,
    double value,
  ) {
    return _spine_to_property_set__scale(
      self,
      value,
    );
  }

  late final _spine_to_property_set__scalePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_property, ffi.Float)>>('spine_to_property_set__scale');
  late final _spine_to_property_set__scale =
      _spine_to_property_set__scalePtr.asFunction<void Function(spine_to_property, double)>();

  spine_to_rotate spine_to_rotate_create() {
    return _spine_to_rotate_create();
  }

  late final _spine_to_rotate_createPtr =
      _lookup<ffi.NativeFunction<spine_to_rotate Function()>>('spine_to_rotate_create');
  late final _spine_to_rotate_create = _spine_to_rotate_createPtr.asFunction<spine_to_rotate Function()>();

  void spine_to_rotate_dispose(
    spine_to_rotate self,
  ) {
    return _spine_to_rotate_dispose(
      self,
    );
  }

  late final _spine_to_rotate_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_rotate)>>('spine_to_rotate_dispose');
  late final _spine_to_rotate_dispose = _spine_to_rotate_disposePtr.asFunction<void Function(spine_to_rotate)>();

  spine_rtti spine_to_rotate_get_rtti(
    spine_to_rotate self,
  ) {
    return _spine_to_rotate_get_rtti(
      self,
    );
  }

  late final _spine_to_rotate_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_rotate)>>('spine_to_rotate_get_rtti');
  late final _spine_to_rotate_get_rtti =
      _spine_to_rotate_get_rttiPtr.asFunction<spine_rtti Function(spine_to_rotate)>();

  double spine_to_rotate_mix(
    spine_to_rotate self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_rotate_mix(
      self,
      pose,
    );
  }

  late final _spine_to_rotate_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_to_rotate, spine_transform_constraint_pose)>>(
          'spine_to_rotate_mix');
  late final _spine_to_rotate_mix =
      _spine_to_rotate_mixPtr.asFunction<double Function(spine_to_rotate, spine_transform_constraint_pose)>();

  void spine_to_rotate_apply(
    spine_to_rotate self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_rotate_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_rotate_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_to_rotate, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose,
              ffi.Float, ffi.Bool, ffi.Bool)>>('spine_to_rotate_apply');
  late final _spine_to_rotate_apply = _spine_to_rotate_applyPtr.asFunction<
      void Function(
          spine_to_rotate, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose, double, bool, bool)>();

  spine_rtti spine_to_rotate_rtti() {
    return _spine_to_rotate_rtti();
  }

  late final _spine_to_rotate_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_to_rotate_rtti');
  late final _spine_to_rotate_rtti = _spine_to_rotate_rttiPtr.asFunction<spine_rtti Function()>();

  spine_to_scale_x spine_to_scale_x_create() {
    return _spine_to_scale_x_create();
  }

  late final _spine_to_scale_x_createPtr =
      _lookup<ffi.NativeFunction<spine_to_scale_x Function()>>('spine_to_scale_x_create');
  late final _spine_to_scale_x_create = _spine_to_scale_x_createPtr.asFunction<spine_to_scale_x Function()>();

  void spine_to_scale_x_dispose(
    spine_to_scale_x self,
  ) {
    return _spine_to_scale_x_dispose(
      self,
    );
  }

  late final _spine_to_scale_x_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_scale_x)>>('spine_to_scale_x_dispose');
  late final _spine_to_scale_x_dispose = _spine_to_scale_x_disposePtr.asFunction<void Function(spine_to_scale_x)>();

  spine_rtti spine_to_scale_x_get_rtti(
    spine_to_scale_x self,
  ) {
    return _spine_to_scale_x_get_rtti(
      self,
    );
  }

  late final _spine_to_scale_x_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_scale_x)>>('spine_to_scale_x_get_rtti');
  late final _spine_to_scale_x_get_rtti =
      _spine_to_scale_x_get_rttiPtr.asFunction<spine_rtti Function(spine_to_scale_x)>();

  double spine_to_scale_x_mix(
    spine_to_scale_x self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_scale_x_mix(
      self,
      pose,
    );
  }

  late final _spine_to_scale_x_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_to_scale_x, spine_transform_constraint_pose)>>(
          'spine_to_scale_x_mix');
  late final _spine_to_scale_x_mix =
      _spine_to_scale_x_mixPtr.asFunction<double Function(spine_to_scale_x, spine_transform_constraint_pose)>();

  void spine_to_scale_x_apply(
    spine_to_scale_x self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_scale_x_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_scale_x_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_to_scale_x, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose,
              ffi.Float, ffi.Bool, ffi.Bool)>>('spine_to_scale_x_apply');
  late final _spine_to_scale_x_apply = _spine_to_scale_x_applyPtr.asFunction<
      void Function(
          spine_to_scale_x, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose, double, bool, bool)>();

  spine_rtti spine_to_scale_x_rtti() {
    return _spine_to_scale_x_rtti();
  }

  late final _spine_to_scale_x_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_to_scale_x_rtti');
  late final _spine_to_scale_x_rtti = _spine_to_scale_x_rttiPtr.asFunction<spine_rtti Function()>();

  spine_to_scale_y spine_to_scale_y_create() {
    return _spine_to_scale_y_create();
  }

  late final _spine_to_scale_y_createPtr =
      _lookup<ffi.NativeFunction<spine_to_scale_y Function()>>('spine_to_scale_y_create');
  late final _spine_to_scale_y_create = _spine_to_scale_y_createPtr.asFunction<spine_to_scale_y Function()>();

  void spine_to_scale_y_dispose(
    spine_to_scale_y self,
  ) {
    return _spine_to_scale_y_dispose(
      self,
    );
  }

  late final _spine_to_scale_y_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_scale_y)>>('spine_to_scale_y_dispose');
  late final _spine_to_scale_y_dispose = _spine_to_scale_y_disposePtr.asFunction<void Function(spine_to_scale_y)>();

  spine_rtti spine_to_scale_y_get_rtti(
    spine_to_scale_y self,
  ) {
    return _spine_to_scale_y_get_rtti(
      self,
    );
  }

  late final _spine_to_scale_y_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_scale_y)>>('spine_to_scale_y_get_rtti');
  late final _spine_to_scale_y_get_rtti =
      _spine_to_scale_y_get_rttiPtr.asFunction<spine_rtti Function(spine_to_scale_y)>();

  double spine_to_scale_y_mix(
    spine_to_scale_y self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_scale_y_mix(
      self,
      pose,
    );
  }

  late final _spine_to_scale_y_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_to_scale_y, spine_transform_constraint_pose)>>(
          'spine_to_scale_y_mix');
  late final _spine_to_scale_y_mix =
      _spine_to_scale_y_mixPtr.asFunction<double Function(spine_to_scale_y, spine_transform_constraint_pose)>();

  void spine_to_scale_y_apply(
    spine_to_scale_y self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_scale_y_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_scale_y_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_to_scale_y, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose,
              ffi.Float, ffi.Bool, ffi.Bool)>>('spine_to_scale_y_apply');
  late final _spine_to_scale_y_apply = _spine_to_scale_y_applyPtr.asFunction<
      void Function(
          spine_to_scale_y, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose, double, bool, bool)>();

  spine_rtti spine_to_scale_y_rtti() {
    return _spine_to_scale_y_rtti();
  }

  late final _spine_to_scale_y_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_to_scale_y_rtti');
  late final _spine_to_scale_y_rtti = _spine_to_scale_y_rttiPtr.asFunction<spine_rtti Function()>();

  spine_to_shear_y spine_to_shear_y_create() {
    return _spine_to_shear_y_create();
  }

  late final _spine_to_shear_y_createPtr =
      _lookup<ffi.NativeFunction<spine_to_shear_y Function()>>('spine_to_shear_y_create');
  late final _spine_to_shear_y_create = _spine_to_shear_y_createPtr.asFunction<spine_to_shear_y Function()>();

  void spine_to_shear_y_dispose(
    spine_to_shear_y self,
  ) {
    return _spine_to_shear_y_dispose(
      self,
    );
  }

  late final _spine_to_shear_y_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_shear_y)>>('spine_to_shear_y_dispose');
  late final _spine_to_shear_y_dispose = _spine_to_shear_y_disposePtr.asFunction<void Function(spine_to_shear_y)>();

  spine_rtti spine_to_shear_y_get_rtti(
    spine_to_shear_y self,
  ) {
    return _spine_to_shear_y_get_rtti(
      self,
    );
  }

  late final _spine_to_shear_y_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_shear_y)>>('spine_to_shear_y_get_rtti');
  late final _spine_to_shear_y_get_rtti =
      _spine_to_shear_y_get_rttiPtr.asFunction<spine_rtti Function(spine_to_shear_y)>();

  double spine_to_shear_y_mix(
    spine_to_shear_y self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_shear_y_mix(
      self,
      pose,
    );
  }

  late final _spine_to_shear_y_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_to_shear_y, spine_transform_constraint_pose)>>(
          'spine_to_shear_y_mix');
  late final _spine_to_shear_y_mix =
      _spine_to_shear_y_mixPtr.asFunction<double Function(spine_to_shear_y, spine_transform_constraint_pose)>();

  void spine_to_shear_y_apply(
    spine_to_shear_y self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_shear_y_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_shear_y_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_to_shear_y, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose,
              ffi.Float, ffi.Bool, ffi.Bool)>>('spine_to_shear_y_apply');
  late final _spine_to_shear_y_apply = _spine_to_shear_y_applyPtr.asFunction<
      void Function(
          spine_to_shear_y, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose, double, bool, bool)>();

  spine_rtti spine_to_shear_y_rtti() {
    return _spine_to_shear_y_rtti();
  }

  late final _spine_to_shear_y_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_to_shear_y_rtti');
  late final _spine_to_shear_y_rtti = _spine_to_shear_y_rttiPtr.asFunction<spine_rtti Function()>();

  spine_to_x spine_to_x_create() {
    return _spine_to_x_create();
  }

  late final _spine_to_x_createPtr = _lookup<ffi.NativeFunction<spine_to_x Function()>>('spine_to_x_create');
  late final _spine_to_x_create = _spine_to_x_createPtr.asFunction<spine_to_x Function()>();

  void spine_to_x_dispose(
    spine_to_x self,
  ) {
    return _spine_to_x_dispose(
      self,
    );
  }

  late final _spine_to_x_disposePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_x)>>('spine_to_x_dispose');
  late final _spine_to_x_dispose = _spine_to_x_disposePtr.asFunction<void Function(spine_to_x)>();

  spine_rtti spine_to_x_get_rtti(
    spine_to_x self,
  ) {
    return _spine_to_x_get_rtti(
      self,
    );
  }

  late final _spine_to_x_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_x)>>('spine_to_x_get_rtti');
  late final _spine_to_x_get_rtti = _spine_to_x_get_rttiPtr.asFunction<spine_rtti Function(spine_to_x)>();

  double spine_to_x_mix(
    spine_to_x self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_x_mix(
      self,
      pose,
    );
  }

  late final _spine_to_x_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_to_x, spine_transform_constraint_pose)>>('spine_to_x_mix');
  late final _spine_to_x_mix =
      _spine_to_x_mixPtr.asFunction<double Function(spine_to_x, spine_transform_constraint_pose)>();

  void spine_to_x_apply(
    spine_to_x self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_x_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_x_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_to_x, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose, ffi.Float,
              ffi.Bool, ffi.Bool)>>('spine_to_x_apply');
  late final _spine_to_x_apply = _spine_to_x_applyPtr.asFunction<
      void Function(
          spine_to_x, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose, double, bool, bool)>();

  spine_rtti spine_to_x_rtti() {
    return _spine_to_x_rtti();
  }

  late final _spine_to_x_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_to_x_rtti');
  late final _spine_to_x_rtti = _spine_to_x_rttiPtr.asFunction<spine_rtti Function()>();

  spine_to_y spine_to_y_create() {
    return _spine_to_y_create();
  }

  late final _spine_to_y_createPtr = _lookup<ffi.NativeFunction<spine_to_y Function()>>('spine_to_y_create');
  late final _spine_to_y_create = _spine_to_y_createPtr.asFunction<spine_to_y Function()>();

  void spine_to_y_dispose(
    spine_to_y self,
  ) {
    return _spine_to_y_dispose(
      self,
    );
  }

  late final _spine_to_y_disposePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_y)>>('spine_to_y_dispose');
  late final _spine_to_y_dispose = _spine_to_y_disposePtr.asFunction<void Function(spine_to_y)>();

  spine_rtti spine_to_y_get_rtti(
    spine_to_y self,
  ) {
    return _spine_to_y_get_rtti(
      self,
    );
  }

  late final _spine_to_y_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_y)>>('spine_to_y_get_rtti');
  late final _spine_to_y_get_rtti = _spine_to_y_get_rttiPtr.asFunction<spine_rtti Function(spine_to_y)>();

  double spine_to_y_mix(
    spine_to_y self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_y_mix(
      self,
      pose,
    );
  }

  late final _spine_to_y_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_to_y, spine_transform_constraint_pose)>>('spine_to_y_mix');
  late final _spine_to_y_mix =
      _spine_to_y_mixPtr.asFunction<double Function(spine_to_y, spine_transform_constraint_pose)>();

  void spine_to_y_apply(
    spine_to_y self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_y_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_y_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_to_y, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose, ffi.Float,
              ffi.Bool, ffi.Bool)>>('spine_to_y_apply');
  late final _spine_to_y_apply = _spine_to_y_applyPtr.asFunction<
      void Function(
          spine_to_y, spine_skeleton, spine_transform_constraint_pose, spine_bone_pose, double, bool, bool)>();

  spine_rtti spine_to_y_rtti() {
    return _spine_to_y_rtti();
  }

  late final _spine_to_y_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_to_y_rtti');
  late final _spine_to_y_rtti = _spine_to_y_rttiPtr.asFunction<spine_rtti Function()>();

  spine_track_entry spine_track_entry_create() {
    return _spine_track_entry_create();
  }

  late final _spine_track_entry_createPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function()>>('spine_track_entry_create');
  late final _spine_track_entry_create = _spine_track_entry_createPtr.asFunction<spine_track_entry Function()>();

  void spine_track_entry_dispose(
    spine_track_entry self,
  ) {
    return _spine_track_entry_dispose(
      self,
    );
  }

  late final _spine_track_entry_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry)>>('spine_track_entry_dispose');
  late final _spine_track_entry_dispose = _spine_track_entry_disposePtr.asFunction<void Function(spine_track_entry)>();

  /// The index of the track where this entry is either current or queued.
  int spine_track_entry_get_track_index(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_track_index(
      self,
    );
  }

  late final _spine_track_entry_get_track_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_track_entry)>>('spine_track_entry_get_track_index');
  late final _spine_track_entry_get_track_index =
      _spine_track_entry_get_track_indexPtr.asFunction<int Function(spine_track_entry)>();

  /// The animation to apply for this track entry.
  spine_animation spine_track_entry_get_animation(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_animation(
      self,
    );
  }

  late final _spine_track_entry_get_animationPtr =
      _lookup<ffi.NativeFunction<spine_animation Function(spine_track_entry)>>('spine_track_entry_get_animation');
  late final _spine_track_entry_get_animation =
      _spine_track_entry_get_animationPtr.asFunction<spine_animation Function(spine_track_entry)>();

  /// Sets the animation for this track entry.
  void spine_track_entry_set_animation(
    spine_track_entry self,
    spine_animation animation,
  ) {
    return _spine_track_entry_set_animation(
      self,
      animation,
    );
  }

  late final _spine_track_entry_set_animationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, spine_animation)>>(
          'spine_track_entry_set_animation');
  late final _spine_track_entry_set_animation =
      _spine_track_entry_set_animationPtr.asFunction<void Function(spine_track_entry, spine_animation)>();

  spine_track_entry spine_track_entry_get_previous(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_previous(
      self,
    );
  }

  late final _spine_track_entry_get_previousPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>('spine_track_entry_get_previous');
  late final _spine_track_entry_get_previous =
      _spine_track_entry_get_previousPtr.asFunction<spine_track_entry Function(spine_track_entry)>();

  /// If true, the animation will repeat. If false, it will not, instead its last
  /// frame is applied if played beyond its duration.
  bool spine_track_entry_get_loop(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_loop(
      self,
    );
  }

  late final _spine_track_entry_get_loopPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>('spine_track_entry_get_loop');
  late final _spine_track_entry_get_loop =
      _spine_track_entry_get_loopPtr.asFunction<bool Function(spine_track_entry)>();

  void spine_track_entry_set_loop(
    spine_track_entry self,
    bool inValue,
  ) {
    return _spine_track_entry_set_loop(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_loopPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Bool)>>('spine_track_entry_set_loop');
  late final _spine_track_entry_set_loop =
      _spine_track_entry_set_loopPtr.asFunction<void Function(spine_track_entry, bool)>();

  /// If true, when mixing from the previous animation to this animation, the
  /// previous animation is applied as normal instead of being mixed out.
  ///
  /// When mixing between animations that key the same property, if a lower track
  /// also keys that property then the value will briefly dip toward the lower
  /// track value during the mix. This happens because the first animation mixes
  /// from 100% to 0% while the second animation mixes from 0% to 100%. Setting
  /// holdPrevious to true applies the first animation at 100% during the mix so
  /// the lower track value is overwritten. Such dipping does not occur on the
  /// lowest track which keys the property, only when a higher track also keys the
  /// property.
  ///
  /// Snapping will occur if holdPrevious is true and this animation does not key
  /// all the same properties as the previous animation.
  bool spine_track_entry_get_hold_previous(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_hold_previous(
      self,
    );
  }

  late final _spine_track_entry_get_hold_previousPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>('spine_track_entry_get_hold_previous');
  late final _spine_track_entry_get_hold_previous =
      _spine_track_entry_get_hold_previousPtr.asFunction<bool Function(spine_track_entry)>();

  void spine_track_entry_set_hold_previous(
    spine_track_entry self,
    bool inValue,
  ) {
    return _spine_track_entry_set_hold_previous(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_hold_previousPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Bool)>>(
          'spine_track_entry_set_hold_previous');
  late final _spine_track_entry_set_hold_previous =
      _spine_track_entry_set_hold_previousPtr.asFunction<void Function(spine_track_entry, bool)>();

  bool spine_track_entry_get_reverse(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_reverse(
      self,
    );
  }

  late final _spine_track_entry_get_reversePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>('spine_track_entry_get_reverse');
  late final _spine_track_entry_get_reverse =
      _spine_track_entry_get_reversePtr.asFunction<bool Function(spine_track_entry)>();

  void spine_track_entry_set_reverse(
    spine_track_entry self,
    bool inValue,
  ) {
    return _spine_track_entry_set_reverse(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_reversePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Bool)>>('spine_track_entry_set_reverse');
  late final _spine_track_entry_set_reverse =
      _spine_track_entry_set_reversePtr.asFunction<void Function(spine_track_entry, bool)>();

  bool spine_track_entry_get_shortest_rotation(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_shortest_rotation(
      self,
    );
  }

  late final _spine_track_entry_get_shortest_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>('spine_track_entry_get_shortest_rotation');
  late final _spine_track_entry_get_shortest_rotation =
      _spine_track_entry_get_shortest_rotationPtr.asFunction<bool Function(spine_track_entry)>();

  void spine_track_entry_set_shortest_rotation(
    spine_track_entry self,
    bool inValue,
  ) {
    return _spine_track_entry_set_shortest_rotation(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_shortest_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Bool)>>(
          'spine_track_entry_set_shortest_rotation');
  late final _spine_track_entry_set_shortest_rotation =
      _spine_track_entry_set_shortest_rotationPtr.asFunction<void Function(spine_track_entry, bool)>();

  /// Seconds to postpone playing the animation. Must be >= 0. When this track
  /// entry is the current track entry, delay postpones incrementing the
  /// getTrackTime(). When this track entry is queued, delay is the time from the
  /// start of the previous animation to when this track entry will become the
  /// current track entry (ie when the previous track entry getTrackTime() >= this
  /// track entry's delay).
  ///
  /// getTimeScale() affects the delay.
  ///
  /// When passing delay < = 0 to AnimationState::addAnimation(int, Animation,
  /// bool, float) this delay is set using a mix duration from AnimationStateData.
  /// To change the getMixDuration() afterward, use setMixDuration(float, float) so
  /// this delay is adjusted.
  double spine_track_entry_get_delay(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_delay(
      self,
    );
  }

  late final _spine_track_entry_get_delayPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_delay');
  late final _spine_track_entry_get_delay =
      _spine_track_entry_get_delayPtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_delay(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_delay(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_delayPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_delay');
  late final _spine_track_entry_set_delay =
      _spine_track_entry_set_delayPtr.asFunction<void Function(spine_track_entry, double)>();

  /// Current time in seconds this track entry has been the current track entry.
  /// The track time determines getAnimationTime(). The track time can be set to
  /// start the animation at a time other than 0, without affecting looping.
  double spine_track_entry_get_track_time(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_track_time(
      self,
    );
  }

  late final _spine_track_entry_get_track_timePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_track_time');
  late final _spine_track_entry_get_track_time =
      _spine_track_entry_get_track_timePtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_track_time(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_track_time(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_track_timePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_track_time');
  late final _spine_track_entry_set_track_time =
      _spine_track_entry_set_track_timePtr.asFunction<void Function(spine_track_entry, double)>();

  /// The track time in seconds when this animation will be removed from the track.
  /// Defaults to the highest possible float value, meaning the animation will be
  /// applied until a new animation is set or the track is cleared. If the track
  /// end time is reached, no other animations are queued for playback, and mixing
  /// from any previous animations is complete, then the properties keyed by the
  /// animation are set to the setup pose and the track is cleared.
  ///
  /// It may be desired to use AnimationState::addEmptyAnimation(int, float, float)
  /// rather than have the animation abruptly cease being applied.
  double spine_track_entry_get_track_end(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_track_end(
      self,
    );
  }

  late final _spine_track_entry_get_track_endPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_track_end');
  late final _spine_track_entry_get_track_end =
      _spine_track_entry_get_track_endPtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_track_end(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_track_end(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_track_endPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_track_end');
  late final _spine_track_entry_set_track_end =
      _spine_track_entry_set_track_endPtr.asFunction<void Function(spine_track_entry, double)>();

  /// Seconds when this animation starts, both initially and after looping.
  /// Defaults to 0.
  ///
  /// When changing the animation start time, it often makes sense to set
  /// TrackEntry.AnimationLast to the same value to prevent timeline keys before
  /// the start time from triggering.
  double spine_track_entry_get_animation_start(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_animation_start(
      self,
    );
  }

  late final _spine_track_entry_get_animation_startPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_animation_start');
  late final _spine_track_entry_get_animation_start =
      _spine_track_entry_get_animation_startPtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_animation_start(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_animation_start(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_animation_startPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
          'spine_track_entry_set_animation_start');
  late final _spine_track_entry_set_animation_start =
      _spine_track_entry_set_animation_startPtr.asFunction<void Function(spine_track_entry, double)>();

  /// Seconds for the last frame of this animation. Non-looping animations won't
  /// play past this time. Looping animations will loop back to
  /// TrackEntry.AnimationStart at this time. Defaults to the animation duration.
  double spine_track_entry_get_animation_end(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_animation_end(
      self,
    );
  }

  late final _spine_track_entry_get_animation_endPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_animation_end');
  late final _spine_track_entry_get_animation_end =
      _spine_track_entry_get_animation_endPtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_animation_end(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_animation_end(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_animation_endPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
          'spine_track_entry_set_animation_end');
  late final _spine_track_entry_set_animation_end =
      _spine_track_entry_set_animation_endPtr.asFunction<void Function(spine_track_entry, double)>();

  /// The time in seconds this animation was last applied. Some timelines use this
  /// for one-time triggers. Eg, when this animation is applied, event timelines
  /// will fire all events between the animation last time (exclusive) and
  /// animation time (inclusive). Defaults to -1 to ensure triggers on frame 0
  /// happen the first time this animation is applied.
  double spine_track_entry_get_animation_last(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_animation_last(
      self,
    );
  }

  late final _spine_track_entry_get_animation_lastPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_animation_last');
  late final _spine_track_entry_get_animation_last =
      _spine_track_entry_get_animation_lastPtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_animation_last(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_animation_last(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_animation_lastPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
          'spine_track_entry_set_animation_last');
  late final _spine_track_entry_set_animation_last =
      _spine_track_entry_set_animation_lastPtr.asFunction<void Function(spine_track_entry, double)>();

  /// Uses getTrackTime() to compute the animationTime. When the trackTime is 0,
  /// the animationTime is equal to the animationStart time.
  ///
  /// The animationTime is between getAnimationStart() and getAnimationEnd(),
  /// except if this track entry is non-looping and getAnimationEnd() is >= to the
  /// animation duration, then animationTime continues to increase past
  /// getAnimationEnd().
  double spine_track_entry_get_animation_time(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_animation_time(
      self,
    );
  }

  late final _spine_track_entry_get_animation_timePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_animation_time');
  late final _spine_track_entry_get_animation_time =
      _spine_track_entry_get_animation_timePtr.asFunction<double Function(spine_track_entry)>();

  /// Multiplier for the delta time when this track entry is updated, causing time
  /// for this animation to pass slower or faster. Defaults to 1.
  ///
  /// Values < 0 are not supported. To play an animation in reverse, use
  /// getReverse().
  ///
  /// getMixTime() is not affected by track entry time scale, so getMixDuration()
  /// may need to be adjusted to match the animation speed.
  ///
  /// When using AnimationState::addAnimation(int, Animation, bool, float) with a
  /// delay < = 0, the getDelay() is set using the mix duration from the
  /// AnimationStateData, assuming time scale to be 1. If the time scale is not 1,
  /// the delay may need to be adjusted.
  ///
  /// See AnimationState getTimeScale() for affecting all animations.
  double spine_track_entry_get_time_scale(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_time_scale(
      self,
    );
  }

  late final _spine_track_entry_get_time_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_time_scale');
  late final _spine_track_entry_get_time_scale =
      _spine_track_entry_get_time_scalePtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_time_scale(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_time_scale(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_time_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_time_scale');
  late final _spine_track_entry_set_time_scale =
      _spine_track_entry_set_time_scalePtr.asFunction<void Function(spine_track_entry, double)>();

  /// Values less than 1 mix this animation with the last skeleton pose. Defaults
  /// to 1, which overwrites the last skeleton pose with this animation.
  ///
  /// Typically track 0 is used to completely pose the skeleton, then alpha can be
  /// used on higher tracks. It doesn't make sense to use alpha on track 0 if the
  /// skeleton pose is from the last frame render.
  double spine_track_entry_get_alpha(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_alpha(
      self,
    );
  }

  late final _spine_track_entry_get_alphaPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_alpha');
  late final _spine_track_entry_get_alpha =
      _spine_track_entry_get_alphaPtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_alpha(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_alpha(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_alphaPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_alpha');
  late final _spine_track_entry_set_alpha =
      _spine_track_entry_set_alphaPtr.asFunction<void Function(spine_track_entry, double)>();

  /// When the mix percentage (mix time / mix duration) is less than the event
  /// threshold, event timelines for the animation being mixed out will be applied.
  /// Defaults to 0, so event timelines are not applied for an animation being
  /// mixed out.
  double spine_track_entry_get_event_threshold(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_event_threshold(
      self,
    );
  }

  late final _spine_track_entry_get_event_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_event_threshold');
  late final _spine_track_entry_get_event_threshold =
      _spine_track_entry_get_event_thresholdPtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_event_threshold(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_event_threshold(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_event_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
          'spine_track_entry_set_event_threshold');
  late final _spine_track_entry_set_event_threshold =
      _spine_track_entry_set_event_thresholdPtr.asFunction<void Function(spine_track_entry, double)>();

  /// When the mix percentage (mix time / mix duration) is less than the attachment
  /// threshold, attachment timelines for the animation being mixed out will be
  /// applied. Defaults to 0, so attachment timelines are not applied for an
  /// animation being mixed out.
  double spine_track_entry_get_mix_attachment_threshold(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mix_attachment_threshold(
      self,
    );
  }

  late final _spine_track_entry_get_mix_attachment_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_mix_attachment_threshold');
  late final _spine_track_entry_get_mix_attachment_threshold =
      _spine_track_entry_get_mix_attachment_thresholdPtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_mix_attachment_threshold(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_mix_attachment_threshold(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_mix_attachment_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
          'spine_track_entry_set_mix_attachment_threshold');
  late final _spine_track_entry_set_mix_attachment_threshold =
      _spine_track_entry_set_mix_attachment_thresholdPtr.asFunction<void Function(spine_track_entry, double)>();

  /// When getAlpha() is greater than alphaAttachmentThreshold, attachment
  /// timelines are applied. Defaults to 0, so attachment timelines are always
  /// applied.
  double spine_track_entry_get_alpha_attachment_threshold(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_alpha_attachment_threshold(
      self,
    );
  }

  late final _spine_track_entry_get_alpha_attachment_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_alpha_attachment_threshold');
  late final _spine_track_entry_get_alpha_attachment_threshold =
      _spine_track_entry_get_alpha_attachment_thresholdPtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_alpha_attachment_threshold(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_alpha_attachment_threshold(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_alpha_attachment_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
          'spine_track_entry_set_alpha_attachment_threshold');
  late final _spine_track_entry_set_alpha_attachment_threshold =
      _spine_track_entry_set_alpha_attachment_thresholdPtr.asFunction<void Function(spine_track_entry, double)>();

  /// When the mix percentage (mix time / mix duration) is less than the draw order
  /// threshold, draw order timelines for the animation being mixed out will be
  /// applied. Defaults to 0, so draw order timelines are not applied for an
  /// animation being mixed out.
  double spine_track_entry_get_mix_draw_order_threshold(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mix_draw_order_threshold(
      self,
    );
  }

  late final _spine_track_entry_get_mix_draw_order_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_mix_draw_order_threshold');
  late final _spine_track_entry_get_mix_draw_order_threshold =
      _spine_track_entry_get_mix_draw_order_thresholdPtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_mix_draw_order_threshold(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_mix_draw_order_threshold(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_mix_draw_order_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
          'spine_track_entry_set_mix_draw_order_threshold');
  late final _spine_track_entry_set_mix_draw_order_threshold =
      _spine_track_entry_set_mix_draw_order_thresholdPtr.asFunction<void Function(spine_track_entry, double)>();

  spine_track_entry spine_track_entry_get_next(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_next(
      self,
    );
  }

  late final _spine_track_entry_get_nextPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>('spine_track_entry_get_next');
  late final _spine_track_entry_get_next =
      _spine_track_entry_get_nextPtr.asFunction<spine_track_entry Function(spine_track_entry)>();

  /// Returns true if at least one loop has been completed.
  bool spine_track_entry_is_complete(
    spine_track_entry self,
  ) {
    return _spine_track_entry_is_complete(
      self,
    );
  }

  late final _spine_track_entry_is_completePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>('spine_track_entry_is_complete');
  late final _spine_track_entry_is_complete =
      _spine_track_entry_is_completePtr.asFunction<bool Function(spine_track_entry)>();

  /// Seconds from 0 to the mix duration when mixing from the previous animation to
  /// this animation. May be slightly more than TrackEntry.MixDuration when the mix
  /// is complete.
  double spine_track_entry_get_mix_time(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mix_time(
      self,
    );
  }

  late final _spine_track_entry_get_mix_timePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_mix_time');
  late final _spine_track_entry_get_mix_time =
      _spine_track_entry_get_mix_timePtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_mix_time(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_mix_time(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_mix_timePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_mix_time');
  late final _spine_track_entry_set_mix_time =
      _spine_track_entry_set_mix_timePtr.asFunction<void Function(spine_track_entry, double)>();

  /// Seconds for mixing from the previous animation to this animation. Defaults to
  /// the value provided by AnimationStateData based on the animation before this
  /// animation (if any).
  ///
  /// The mix duration can be set manually rather than use the value from
  /// AnimationStateData.GetMix. In that case, the mixDuration must be set before
  /// AnimationState.update(float) is next called.
  ///
  /// When using AnimationState::addAnimation(int, Animation, bool, float) with a
  /// delay less than or equal to 0, note the Delay is set using the mix duration
  /// from the AnimationStateData
  double spine_track_entry_get_mix_duration(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mix_duration(
      self,
    );
  }

  late final _spine_track_entry_get_mix_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_mix_duration');
  late final _spine_track_entry_get_mix_duration =
      _spine_track_entry_get_mix_durationPtr.asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_mix_duration_1(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_mix_duration_1(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_mix_duration_1Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
          'spine_track_entry_set_mix_duration_1');
  late final _spine_track_entry_set_mix_duration_1 =
      _spine_track_entry_set_mix_duration_1Ptr.asFunction<void Function(spine_track_entry, double)>();

  /// Sets both getMixDuration() and getDelay().
  ///
  /// @param delay If > 0, sets TrackEntry::getDelay(). If < = 0, the delay set is the duration of the previous track entry minus the specified mix duration plus the specified delay (ie the mix ends at (delay = 0) or before (delay < 0) the previous track entry duration). If the previous entry is looping, its next loop completion is used instead of its duration.
  void spine_track_entry_set_mix_duration_2(
    spine_track_entry self,
    double mixDuration,
    double delay,
  ) {
    return _spine_track_entry_set_mix_duration_2(
      self,
      mixDuration,
      delay,
    );
  }

  late final _spine_track_entry_set_mix_duration_2Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float, ffi.Float)>>(
          'spine_track_entry_set_mix_duration_2');
  late final _spine_track_entry_set_mix_duration_2 =
      _spine_track_entry_set_mix_duration_2Ptr.asFunction<void Function(spine_track_entry, double, double)>();

  int spine_track_entry_get_mix_blend(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mix_blend(
      self,
    );
  }

  late final _spine_track_entry_get_mix_blendPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>('spine_track_entry_get_mix_blend');
  late final _spine_track_entry_get_mix_blend =
      _spine_track_entry_get_mix_blendPtr.asFunction<int Function(spine_track_entry)>();

  void spine_track_entry_set_mix_blend(
    spine_track_entry self,
    int blend,
  ) {
    return _spine_track_entry_set_mix_blend(
      self,
      blend,
    );
  }

  late final _spine_track_entry_set_mix_blendPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>('spine_track_entry_set_mix_blend');
  late final _spine_track_entry_set_mix_blend =
      _spine_track_entry_set_mix_blendPtr.asFunction<void Function(spine_track_entry, int)>();

  spine_track_entry spine_track_entry_get_mixing_from(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mixing_from(
      self,
    );
  }

  late final _spine_track_entry_get_mixing_fromPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>('spine_track_entry_get_mixing_from');
  late final _spine_track_entry_get_mixing_from =
      _spine_track_entry_get_mixing_fromPtr.asFunction<spine_track_entry Function(spine_track_entry)>();

  spine_track_entry spine_track_entry_get_mixing_to(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mixing_to(
      self,
    );
  }

  late final _spine_track_entry_get_mixing_toPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>('spine_track_entry_get_mixing_to');
  late final _spine_track_entry_get_mixing_to =
      _spine_track_entry_get_mixing_toPtr.asFunction<spine_track_entry Function(spine_track_entry)>();

  /// Resets the rotation directions for mixing this entry's rotate timelines. This
  /// can be useful to avoid bones rotating the long way around when using alpha
  /// and starting animations on other tracks.
  ///
  /// Mixing involves finding a rotation between two others, which has two possible
  /// solutions: the short way or the long way around. The two rotations likely
  /// change over time, so which direction is the short or long way also changes.
  /// If the short way was always chosen, bones would flip to the other side when
  /// that direction became the long way. TrackEntry chooses the short way the
  /// first time it is applied and remembers that direction.
  void spine_track_entry_reset_rotation_directions(
    spine_track_entry self,
  ) {
    return _spine_track_entry_reset_rotation_directions(
      self,
    );
  }

  late final _spine_track_entry_reset_rotation_directionsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry)>>('spine_track_entry_reset_rotation_directions');
  late final _spine_track_entry_reset_rotation_directions =
      _spine_track_entry_reset_rotation_directionsPtr.asFunction<void Function(spine_track_entry)>();

  double spine_track_entry_get_track_complete(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_track_complete(
      self,
    );
  }

  late final _spine_track_entry_get_track_completePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_track_complete');
  late final _spine_track_entry_get_track_complete =
      _spine_track_entry_get_track_completePtr.asFunction<double Function(spine_track_entry)>();

  /// Returns true if this entry is for the empty animation.
  bool spine_track_entry_is_empty_animation(
    spine_track_entry self,
  ) {
    return _spine_track_entry_is_empty_animation(
      self,
    );
  }

  late final _spine_track_entry_is_empty_animationPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>('spine_track_entry_is_empty_animation');
  late final _spine_track_entry_is_empty_animation =
      _spine_track_entry_is_empty_animationPtr.asFunction<bool Function(spine_track_entry)>();

  /// Returns true if this track entry has been applied at least once.
  ///
  /// See AnimationState::apply(Skeleton).
  bool spine_track_entry_was_applied(
    spine_track_entry self,
  ) {
    return _spine_track_entry_was_applied(
      self,
    );
  }

  late final _spine_track_entry_was_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>('spine_track_entry_was_applied');
  late final _spine_track_entry_was_applied =
      _spine_track_entry_was_appliedPtr.asFunction<bool Function(spine_track_entry)>();

  /// Returns true if there is a getNext() track entry that is ready to become the
  /// current track entry during the next AnimationState::update(float)}
  bool spine_track_entry_is_next_ready(
    spine_track_entry self,
  ) {
    return _spine_track_entry_is_next_ready(
      self,
    );
  }

  late final _spine_track_entry_is_next_readyPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>('spine_track_entry_is_next_ready');
  late final _spine_track_entry_is_next_ready =
      _spine_track_entry_is_next_readyPtr.asFunction<bool Function(spine_track_entry)>();

  spine_animation_state spine_track_entry_get_animation_state(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_animation_state(
      self,
    );
  }

  late final _spine_track_entry_get_animation_statePtr =
      _lookup<ffi.NativeFunction<spine_animation_state Function(spine_track_entry)>>(
          'spine_track_entry_get_animation_state');
  late final _spine_track_entry_get_animation_state =
      _spine_track_entry_get_animation_statePtr.asFunction<spine_animation_state Function(spine_track_entry)>();

  void spine_track_entry_set_animation_state(
    spine_track_entry self,
    spine_animation_state state,
  ) {
    return _spine_track_entry_set_animation_state(
      self,
      state,
    );
  }

  late final _spine_track_entry_set_animation_statePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, spine_animation_state)>>(
          'spine_track_entry_set_animation_state');
  late final _spine_track_entry_set_animation_state =
      _spine_track_entry_set_animation_statePtr.asFunction<void Function(spine_track_entry, spine_animation_state)>();

  ffi.Pointer<ffi.Void> spine_track_entry_get_renderer_object(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_renderer_object(
      self,
    );
  }

  late final _spine_track_entry_get_renderer_objectPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(spine_track_entry)>>(
          'spine_track_entry_get_renderer_object');
  late final _spine_track_entry_get_renderer_object =
      _spine_track_entry_get_renderer_objectPtr.asFunction<ffi.Pointer<ffi.Void> Function(spine_track_entry)>();

  spine_transform_constraint spine_transform_constraint_create(
    spine_transform_constraint_data data,
    spine_skeleton skeleton,
  ) {
    return _spine_transform_constraint_create(
      data,
      skeleton,
    );
  }

  late final _spine_transform_constraint_createPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint Function(spine_transform_constraint_data, spine_skeleton)>>(
          'spine_transform_constraint_create');
  late final _spine_transform_constraint_create = _spine_transform_constraint_createPtr
      .asFunction<spine_transform_constraint Function(spine_transform_constraint_data, spine_skeleton)>();

  void spine_transform_constraint_dispose(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_dispose(
      self,
    );
  }

  late final _spine_transform_constraint_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint)>>('spine_transform_constraint_dispose');
  late final _spine_transform_constraint_dispose =
      _spine_transform_constraint_disposePtr.asFunction<void Function(spine_transform_constraint)>();

  spine_rtti spine_transform_constraint_get_rtti(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_get_rtti(
      self,
    );
  }

  late final _spine_transform_constraint_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_transform_constraint)>>(
          'spine_transform_constraint_get_rtti');
  late final _spine_transform_constraint_get_rtti =
      _spine_transform_constraint_get_rttiPtr.asFunction<spine_rtti Function(spine_transform_constraint)>();

  spine_transform_constraint spine_transform_constraint_copy(
    spine_transform_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_transform_constraint_copy(
      self,
      skeleton,
    );
  }

  late final _spine_transform_constraint_copyPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint Function(spine_transform_constraint, spine_skeleton)>>(
          'spine_transform_constraint_copy');
  late final _spine_transform_constraint_copy = _spine_transform_constraint_copyPtr
      .asFunction<spine_transform_constraint Function(spine_transform_constraint, spine_skeleton)>();

  /// Applies the constraint to the constrained bones.
  void spine_transform_constraint_update(
    spine_transform_constraint self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_transform_constraint_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_transform_constraint_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, spine_skeleton, ffi.Int32)>>(
          'spine_transform_constraint_update');
  late final _spine_transform_constraint_update = _spine_transform_constraint_updatePtr
      .asFunction<void Function(spine_transform_constraint, spine_skeleton, int)>();

  void spine_transform_constraint_sort(
    spine_transform_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_transform_constraint_sort(
      self,
      skeleton,
    );
  }

  late final _spine_transform_constraint_sortPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, spine_skeleton)>>(
          'spine_transform_constraint_sort');
  late final _spine_transform_constraint_sort =
      _spine_transform_constraint_sortPtr.asFunction<void Function(spine_transform_constraint, spine_skeleton)>();

  bool spine_transform_constraint_is_source_active(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_is_source_active(
      self,
    );
  }

  late final _spine_transform_constraint_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint)>>(
          'spine_transform_constraint_is_source_active');
  late final _spine_transform_constraint_is_source_active =
      _spine_transform_constraint_is_source_activePtr.asFunction<bool Function(spine_transform_constraint)>();

  /// The bones that will be modified by this transform constraint.
  spine_array_bone_pose spine_transform_constraint_get_bones(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_get_bones(
      self,
    );
  }

  late final _spine_transform_constraint_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_bone_pose Function(spine_transform_constraint)>>(
          'spine_transform_constraint_get_bones');
  late final _spine_transform_constraint_get_bones =
      _spine_transform_constraint_get_bonesPtr.asFunction<spine_array_bone_pose Function(spine_transform_constraint)>();

  /// The bone whose world transform will be copied to the constrained bones.
  spine_bone spine_transform_constraint_get_source(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_get_source(
      self,
    );
  }

  late final _spine_transform_constraint_get_sourcePtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_transform_constraint)>>(
          'spine_transform_constraint_get_source');
  late final _spine_transform_constraint_get_source =
      _spine_transform_constraint_get_sourcePtr.asFunction<spine_bone Function(spine_transform_constraint)>();

  void spine_transform_constraint_set_source(
    spine_transform_constraint self,
    spine_bone source,
  ) {
    return _spine_transform_constraint_set_source(
      self,
      source,
    );
  }

  late final _spine_transform_constraint_set_sourcePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, spine_bone)>>(
          'spine_transform_constraint_set_source');
  late final _spine_transform_constraint_set_source =
      _spine_transform_constraint_set_sourcePtr.asFunction<void Function(spine_transform_constraint, spine_bone)>();

  spine_transform_constraint_data spine_transform_constraint_get_data(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_get_data(
      self,
    );
  }

  late final _spine_transform_constraint_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_data Function(spine_transform_constraint)>>(
          'spine_transform_constraint_get_data');
  late final _spine_transform_constraint_get_data = _spine_transform_constraint_get_dataPtr
      .asFunction<spine_transform_constraint_data Function(spine_transform_constraint)>();

  spine_transform_constraint_pose spine_transform_constraint_get_pose(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_get_pose(
      self,
    );
  }

  late final _spine_transform_constraint_get_posePtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_pose Function(spine_transform_constraint)>>(
          'spine_transform_constraint_get_pose');
  late final _spine_transform_constraint_get_pose = _spine_transform_constraint_get_posePtr
      .asFunction<spine_transform_constraint_pose Function(spine_transform_constraint)>();

  spine_transform_constraint_pose spine_transform_constraint_get_applied_pose(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_get_applied_pose(
      self,
    );
  }

  late final _spine_transform_constraint_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_pose Function(spine_transform_constraint)>>(
          'spine_transform_constraint_get_applied_pose');
  late final _spine_transform_constraint_get_applied_pose = _spine_transform_constraint_get_applied_posePtr
      .asFunction<spine_transform_constraint_pose Function(spine_transform_constraint)>();

  void spine_transform_constraint_reset_constrained(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_reset_constrained(
      self,
    );
  }

  late final _spine_transform_constraint_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint)>>(
          'spine_transform_constraint_reset_constrained');
  late final _spine_transform_constraint_reset_constrained =
      _spine_transform_constraint_reset_constrainedPtr.asFunction<void Function(spine_transform_constraint)>();

  void spine_transform_constraint_constrained(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_constrained(
      self,
    );
  }

  late final _spine_transform_constraint_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint)>>(
          'spine_transform_constraint_constrained');
  late final _spine_transform_constraint_constrained =
      _spine_transform_constraint_constrainedPtr.asFunction<void Function(spine_transform_constraint)>();

  bool spine_transform_constraint_is_pose_equal_to_applied(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_transform_constraint_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint)>>(
          'spine_transform_constraint_is_pose_equal_to_applied');
  late final _spine_transform_constraint_is_pose_equal_to_applied =
      _spine_transform_constraint_is_pose_equal_to_appliedPtr.asFunction<bool Function(spine_transform_constraint)>();

  bool spine_transform_constraint_is_active(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_is_active(
      self,
    );
  }

  late final _spine_transform_constraint_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint)>>(
          'spine_transform_constraint_is_active');
  late final _spine_transform_constraint_is_active =
      _spine_transform_constraint_is_activePtr.asFunction<bool Function(spine_transform_constraint)>();

  void spine_transform_constraint_set_active(
    spine_transform_constraint self,
    bool active,
  ) {
    return _spine_transform_constraint_set_active(
      self,
      active,
    );
  }

  late final _spine_transform_constraint_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, ffi.Bool)>>(
          'spine_transform_constraint_set_active');
  late final _spine_transform_constraint_set_active =
      _spine_transform_constraint_set_activePtr.asFunction<void Function(spine_transform_constraint, bool)>();

  spine_rtti spine_transform_constraint_rtti() {
    return _spine_transform_constraint_rtti();
  }

  late final _spine_transform_constraint_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_transform_constraint_rtti');
  late final _spine_transform_constraint_rtti = _spine_transform_constraint_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_transform_constraint_base_dispose(
    spine_transform_constraint_base self,
  ) {
    return _spine_transform_constraint_base_dispose(
      self,
    );
  }

  late final _spine_transform_constraint_base_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_dispose');
  late final _spine_transform_constraint_base_dispose =
      _spine_transform_constraint_base_disposePtr.asFunction<void Function(spine_transform_constraint_base)>();

  spine_transform_constraint_data spine_transform_constraint_base_get_data(
    spine_transform_constraint_base self,
  ) {
    return _spine_transform_constraint_base_get_data(
      self,
    );
  }

  late final _spine_transform_constraint_base_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_data Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_get_data');
  late final _spine_transform_constraint_base_get_data = _spine_transform_constraint_base_get_dataPtr
      .asFunction<spine_transform_constraint_data Function(spine_transform_constraint_base)>();

  spine_transform_constraint_pose spine_transform_constraint_base_get_pose(
    spine_transform_constraint_base self,
  ) {
    return _spine_transform_constraint_base_get_pose(
      self,
    );
  }

  late final _spine_transform_constraint_base_get_posePtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_pose Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_get_pose');
  late final _spine_transform_constraint_base_get_pose = _spine_transform_constraint_base_get_posePtr
      .asFunction<spine_transform_constraint_pose Function(spine_transform_constraint_base)>();

  spine_transform_constraint_pose spine_transform_constraint_base_get_applied_pose(
    spine_transform_constraint_base self,
  ) {
    return _spine_transform_constraint_base_get_applied_pose(
      self,
    );
  }

  late final _spine_transform_constraint_base_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_pose Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_get_applied_pose');
  late final _spine_transform_constraint_base_get_applied_pose = _spine_transform_constraint_base_get_applied_posePtr
      .asFunction<spine_transform_constraint_pose Function(spine_transform_constraint_base)>();

  void spine_transform_constraint_base_reset_constrained(
    spine_transform_constraint_base self,
  ) {
    return _spine_transform_constraint_base_reset_constrained(
      self,
    );
  }

  late final _spine_transform_constraint_base_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_reset_constrained');
  late final _spine_transform_constraint_base_reset_constrained = _spine_transform_constraint_base_reset_constrainedPtr
      .asFunction<void Function(spine_transform_constraint_base)>();

  void spine_transform_constraint_base_constrained(
    spine_transform_constraint_base self,
  ) {
    return _spine_transform_constraint_base_constrained(
      self,
    );
  }

  late final _spine_transform_constraint_base_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_constrained');
  late final _spine_transform_constraint_base_constrained =
      _spine_transform_constraint_base_constrainedPtr.asFunction<void Function(spine_transform_constraint_base)>();

  bool spine_transform_constraint_base_is_pose_equal_to_applied(
    spine_transform_constraint_base self,
  ) {
    return _spine_transform_constraint_base_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_transform_constraint_base_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_is_pose_equal_to_applied');
  late final _spine_transform_constraint_base_is_pose_equal_to_applied =
      _spine_transform_constraint_base_is_pose_equal_to_appliedPtr
          .asFunction<bool Function(spine_transform_constraint_base)>();

  bool spine_transform_constraint_base_is_active(
    spine_transform_constraint_base self,
  ) {
    return _spine_transform_constraint_base_is_active(
      self,
    );
  }

  late final _spine_transform_constraint_base_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_is_active');
  late final _spine_transform_constraint_base_is_active =
      _spine_transform_constraint_base_is_activePtr.asFunction<bool Function(spine_transform_constraint_base)>();

  void spine_transform_constraint_base_set_active(
    spine_transform_constraint_base self,
    bool active,
  ) {
    return _spine_transform_constraint_base_set_active(
      self,
      active,
    );
  }

  late final _spine_transform_constraint_base_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_base, ffi.Bool)>>(
          'spine_transform_constraint_base_set_active');
  late final _spine_transform_constraint_base_set_active =
      _spine_transform_constraint_base_set_activePtr.asFunction<void Function(spine_transform_constraint_base, bool)>();

  spine_rtti spine_transform_constraint_base_get_rtti(
    spine_transform_constraint_base self,
  ) {
    return _spine_transform_constraint_base_get_rtti(
      self,
    );
  }

  late final _spine_transform_constraint_base_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_get_rtti');
  late final _spine_transform_constraint_base_get_rtti =
      _spine_transform_constraint_base_get_rttiPtr.asFunction<spine_rtti Function(spine_transform_constraint_base)>();

  void spine_transform_constraint_base_sort(
    spine_transform_constraint_base self,
    spine_skeleton skeleton,
  ) {
    return _spine_transform_constraint_base_sort(
      self,
      skeleton,
    );
  }

  late final _spine_transform_constraint_base_sortPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_base, spine_skeleton)>>(
          'spine_transform_constraint_base_sort');
  late final _spine_transform_constraint_base_sort = _spine_transform_constraint_base_sortPtr
      .asFunction<void Function(spine_transform_constraint_base, spine_skeleton)>();

  bool spine_transform_constraint_base_is_source_active(
    spine_transform_constraint_base self,
  ) {
    return _spine_transform_constraint_base_is_source_active(
      self,
    );
  }

  late final _spine_transform_constraint_base_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint_base)>>(
          'spine_transform_constraint_base_is_source_active');
  late final _spine_transform_constraint_base_is_source_active =
      _spine_transform_constraint_base_is_source_activePtr.asFunction<bool Function(spine_transform_constraint_base)>();

  /// Inherited from Update
  void spine_transform_constraint_base_update(
    spine_transform_constraint_base self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_transform_constraint_base_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_transform_constraint_base_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_base, spine_skeleton, ffi.Int32)>>(
          'spine_transform_constraint_base_update');
  late final _spine_transform_constraint_base_update = _spine_transform_constraint_base_updatePtr
      .asFunction<void Function(spine_transform_constraint_base, spine_skeleton, int)>();

  spine_rtti spine_transform_constraint_base_rtti() {
    return _spine_transform_constraint_base_rtti();
  }

  late final _spine_transform_constraint_base_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_transform_constraint_base_rtti');
  late final _spine_transform_constraint_base_rtti =
      _spine_transform_constraint_base_rttiPtr.asFunction<spine_rtti Function()>();

  spine_transform_constraint_data spine_transform_constraint_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_transform_constraint_data_create(
      name,
    );
  }

  late final _spine_transform_constraint_data_createPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_data Function(ffi.Pointer<ffi.Char>)>>(
          'spine_transform_constraint_data_create');
  late final _spine_transform_constraint_data_create = _spine_transform_constraint_data_createPtr
      .asFunction<spine_transform_constraint_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_transform_constraint_data_dispose(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_dispose(
      self,
    );
  }

  late final _spine_transform_constraint_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_dispose');
  late final _spine_transform_constraint_data_dispose =
      _spine_transform_constraint_data_disposePtr.asFunction<void Function(spine_transform_constraint_data)>();

  spine_rtti spine_transform_constraint_data_get_rtti(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_rtti(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_rtti');
  late final _spine_transform_constraint_data_get_rtti =
      _spine_transform_constraint_data_get_rttiPtr.asFunction<spine_rtti Function(spine_transform_constraint_data)>();

  spine_constraint spine_transform_constraint_data_create_method(
    spine_transform_constraint_data self,
    spine_skeleton skeleton,
  ) {
    return _spine_transform_constraint_data_create_method(
      self,
      skeleton,
    );
  }

  late final _spine_transform_constraint_data_create_methodPtr =
      _lookup<ffi.NativeFunction<spine_constraint Function(spine_transform_constraint_data, spine_skeleton)>>(
          'spine_transform_constraint_data_create_method');
  late final _spine_transform_constraint_data_create_method = _spine_transform_constraint_data_create_methodPtr
      .asFunction<spine_constraint Function(spine_transform_constraint_data, spine_skeleton)>();

  /// The bones that will be modified by this transform constraint.
  spine_array_bone_data spine_transform_constraint_data_get_bones(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_bones(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_bone_data Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_bones');
  late final _spine_transform_constraint_data_get_bones = _spine_transform_constraint_data_get_bonesPtr
      .asFunction<spine_array_bone_data Function(spine_transform_constraint_data)>();

  /// The bone whose world transform will be copied to the constrained bones.
  spine_bone_data spine_transform_constraint_data_get_source(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_source(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_sourcePtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_source');
  late final _spine_transform_constraint_data_get_source = _spine_transform_constraint_data_get_sourcePtr
      .asFunction<spine_bone_data Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_source(
    spine_transform_constraint_data self,
    spine_bone_data source,
  ) {
    return _spine_transform_constraint_data_set_source(
      self,
      source,
    );
  }

  late final _spine_transform_constraint_data_set_sourcePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, spine_bone_data)>>(
          'spine_transform_constraint_data_set_source');
  late final _spine_transform_constraint_data_set_source = _spine_transform_constraint_data_set_sourcePtr
      .asFunction<void Function(spine_transform_constraint_data, spine_bone_data)>();

  /// An offset added to the constrained bone rotation.
  double spine_transform_constraint_data_get_offset_rotation(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_offset_rotation(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_offset_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_offset_rotation');
  late final _spine_transform_constraint_data_get_offset_rotation =
      _spine_transform_constraint_data_get_offset_rotationPtr
          .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_offset_rotation(
    spine_transform_constraint_data self,
    double offsetRotation,
  ) {
    return _spine_transform_constraint_data_set_offset_rotation(
      self,
      offsetRotation,
    );
  }

  late final _spine_transform_constraint_data_set_offset_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
          'spine_transform_constraint_data_set_offset_rotation');
  late final _spine_transform_constraint_data_set_offset_rotation =
      _spine_transform_constraint_data_set_offset_rotationPtr
          .asFunction<void Function(spine_transform_constraint_data, double)>();

  /// An offset added to the constrained bone X translation.
  double spine_transform_constraint_data_get_offset_x(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_offset_x(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_offset_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_offset_x');
  late final _spine_transform_constraint_data_get_offset_x =
      _spine_transform_constraint_data_get_offset_xPtr.asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_offset_x(
    spine_transform_constraint_data self,
    double offsetX,
  ) {
    return _spine_transform_constraint_data_set_offset_x(
      self,
      offsetX,
    );
  }

  late final _spine_transform_constraint_data_set_offset_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
          'spine_transform_constraint_data_set_offset_x');
  late final _spine_transform_constraint_data_set_offset_x = _spine_transform_constraint_data_set_offset_xPtr
      .asFunction<void Function(spine_transform_constraint_data, double)>();

  /// An offset added to the constrained bone Y translation.
  double spine_transform_constraint_data_get_offset_y(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_offset_y(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_offset_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_offset_y');
  late final _spine_transform_constraint_data_get_offset_y =
      _spine_transform_constraint_data_get_offset_yPtr.asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_offset_y(
    spine_transform_constraint_data self,
    double offsetY,
  ) {
    return _spine_transform_constraint_data_set_offset_y(
      self,
      offsetY,
    );
  }

  late final _spine_transform_constraint_data_set_offset_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
          'spine_transform_constraint_data_set_offset_y');
  late final _spine_transform_constraint_data_set_offset_y = _spine_transform_constraint_data_set_offset_yPtr
      .asFunction<void Function(spine_transform_constraint_data, double)>();

  /// An offset added to the constrained bone scaleX.
  double spine_transform_constraint_data_get_offset_scale_x(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_offset_scale_x(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_offset_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_offset_scale_x');
  late final _spine_transform_constraint_data_get_offset_scale_x =
      _spine_transform_constraint_data_get_offset_scale_xPtr
          .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_offset_scale_x(
    spine_transform_constraint_data self,
    double offsetScaleX,
  ) {
    return _spine_transform_constraint_data_set_offset_scale_x(
      self,
      offsetScaleX,
    );
  }

  late final _spine_transform_constraint_data_set_offset_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
          'spine_transform_constraint_data_set_offset_scale_x');
  late final _spine_transform_constraint_data_set_offset_scale_x =
      _spine_transform_constraint_data_set_offset_scale_xPtr
          .asFunction<void Function(spine_transform_constraint_data, double)>();

  /// An offset added to the constrained bone scaleY.
  double spine_transform_constraint_data_get_offset_scale_y(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_offset_scale_y(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_offset_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_offset_scale_y');
  late final _spine_transform_constraint_data_get_offset_scale_y =
      _spine_transform_constraint_data_get_offset_scale_yPtr
          .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_offset_scale_y(
    spine_transform_constraint_data self,
    double offsetScaleY,
  ) {
    return _spine_transform_constraint_data_set_offset_scale_y(
      self,
      offsetScaleY,
    );
  }

  late final _spine_transform_constraint_data_set_offset_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
          'spine_transform_constraint_data_set_offset_scale_y');
  late final _spine_transform_constraint_data_set_offset_scale_y =
      _spine_transform_constraint_data_set_offset_scale_yPtr
          .asFunction<void Function(spine_transform_constraint_data, double)>();

  /// An offset added to the constrained bone shearY.
  double spine_transform_constraint_data_get_offset_shear_y(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_offset_shear_y(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_offset_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_offset_shear_y');
  late final _spine_transform_constraint_data_get_offset_shear_y =
      _spine_transform_constraint_data_get_offset_shear_yPtr
          .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_offset_shear_y(
    spine_transform_constraint_data self,
    double offsetShearY,
  ) {
    return _spine_transform_constraint_data_set_offset_shear_y(
      self,
      offsetShearY,
    );
  }

  late final _spine_transform_constraint_data_set_offset_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
          'spine_transform_constraint_data_set_offset_shear_y');
  late final _spine_transform_constraint_data_set_offset_shear_y =
      _spine_transform_constraint_data_set_offset_shear_yPtr
          .asFunction<void Function(spine_transform_constraint_data, double)>();

  /// Reads the source bone's local transform instead of its world transform.
  bool spine_transform_constraint_data_get_local_source(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_local_source(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_local_sourcePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_local_source');
  late final _spine_transform_constraint_data_get_local_source =
      _spine_transform_constraint_data_get_local_sourcePtr.asFunction<bool Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_local_source(
    spine_transform_constraint_data self,
    bool localSource,
  ) {
    return _spine_transform_constraint_data_set_local_source(
      self,
      localSource,
    );
  }

  late final _spine_transform_constraint_data_set_local_sourcePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Bool)>>(
          'spine_transform_constraint_data_set_local_source');
  late final _spine_transform_constraint_data_set_local_source = _spine_transform_constraint_data_set_local_sourcePtr
      .asFunction<void Function(spine_transform_constraint_data, bool)>();

  /// Sets the constrained bones' local transforms instead of their world
  /// transforms.
  bool spine_transform_constraint_data_get_local_target(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_local_target(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_local_targetPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_local_target');
  late final _spine_transform_constraint_data_get_local_target =
      _spine_transform_constraint_data_get_local_targetPtr.asFunction<bool Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_local_target(
    spine_transform_constraint_data self,
    bool localTarget,
  ) {
    return _spine_transform_constraint_data_set_local_target(
      self,
      localTarget,
    );
  }

  late final _spine_transform_constraint_data_set_local_targetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Bool)>>(
          'spine_transform_constraint_data_set_local_target');
  late final _spine_transform_constraint_data_set_local_target = _spine_transform_constraint_data_set_local_targetPtr
      .asFunction<void Function(spine_transform_constraint_data, bool)>();

  /// Adds the source bone transform to the constrained bones instead of setting it
  /// absolutely.
  bool spine_transform_constraint_data_get_additive(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_additive(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_additivePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_additive');
  late final _spine_transform_constraint_data_get_additive =
      _spine_transform_constraint_data_get_additivePtr.asFunction<bool Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_additive(
    spine_transform_constraint_data self,
    bool additive,
  ) {
    return _spine_transform_constraint_data_set_additive(
      self,
      additive,
    );
  }

  late final _spine_transform_constraint_data_set_additivePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Bool)>>(
          'spine_transform_constraint_data_set_additive');
  late final _spine_transform_constraint_data_set_additive = _spine_transform_constraint_data_set_additivePtr
      .asFunction<void Function(spine_transform_constraint_data, bool)>();

  /// Prevents constrained bones from exceeding the ranged defined by offset and
  /// max.
  bool spine_transform_constraint_data_get_clamp(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_clamp(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_clampPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_clamp');
  late final _spine_transform_constraint_data_get_clamp =
      _spine_transform_constraint_data_get_clampPtr.asFunction<bool Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_clamp(
    spine_transform_constraint_data self,
    bool clamp,
  ) {
    return _spine_transform_constraint_data_set_clamp(
      self,
      clamp,
    );
  }

  late final _spine_transform_constraint_data_set_clampPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Bool)>>(
          'spine_transform_constraint_data_set_clamp');
  late final _spine_transform_constraint_data_set_clamp =
      _spine_transform_constraint_data_set_clampPtr.asFunction<void Function(spine_transform_constraint_data, bool)>();

  /// The mapping of transform properties to other transform properties.
  spine_array_from_property spine_transform_constraint_data_get_properties(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_properties(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_propertiesPtr =
      _lookup<ffi.NativeFunction<spine_array_from_property Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_properties');
  late final _spine_transform_constraint_data_get_properties = _spine_transform_constraint_data_get_propertiesPtr
      .asFunction<spine_array_from_property Function(spine_transform_constraint_data)>();

  /// Resolve ambiguity by forwarding to PosedData's implementation
  ffi.Pointer<ffi.Char> spine_transform_constraint_data_get_name(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_name(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_name');
  late final _spine_transform_constraint_data_get_name = _spine_transform_constraint_data_get_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_transform_constraint_data)>();

  bool spine_transform_constraint_data_get_skin_required(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_skin_required(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_skin_required');
  late final _spine_transform_constraint_data_get_skin_required = _spine_transform_constraint_data_get_skin_requiredPtr
      .asFunction<bool Function(spine_transform_constraint_data)>();

  spine_transform_constraint_pose spine_transform_constraint_data_get_setup_pose(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_setup_pose(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_setup_posePtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_pose Function(spine_transform_constraint_data)>>(
          'spine_transform_constraint_data_get_setup_pose');
  late final _spine_transform_constraint_data_get_setup_pose = _spine_transform_constraint_data_get_setup_posePtr
      .asFunction<spine_transform_constraint_pose Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_skin_required(
    spine_transform_constraint_data self,
    bool skinRequired,
  ) {
    return _spine_transform_constraint_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_transform_constraint_data_set_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Bool)>>(
          'spine_transform_constraint_data_set_skin_required');
  late final _spine_transform_constraint_data_set_skin_required = _spine_transform_constraint_data_set_skin_requiredPtr
      .asFunction<void Function(spine_transform_constraint_data, bool)>();

  spine_rtti spine_transform_constraint_data_rtti() {
    return _spine_transform_constraint_data_rtti();
  }

  late final _spine_transform_constraint_data_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_transform_constraint_data_rtti');
  late final _spine_transform_constraint_data_rtti =
      _spine_transform_constraint_data_rttiPtr.asFunction<spine_rtti Function()>();

  spine_transform_constraint_pose spine_transform_constraint_pose_create() {
    return _spine_transform_constraint_pose_create();
  }

  late final _spine_transform_constraint_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_pose Function()>>('spine_transform_constraint_pose_create');
  late final _spine_transform_constraint_pose_create =
      _spine_transform_constraint_pose_createPtr.asFunction<spine_transform_constraint_pose Function()>();

  void spine_transform_constraint_pose_dispose(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_dispose(
      self,
    );
  }

  late final _spine_transform_constraint_pose_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_pose)>>(
          'spine_transform_constraint_pose_dispose');
  late final _spine_transform_constraint_pose_dispose =
      _spine_transform_constraint_pose_disposePtr.asFunction<void Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set(
    spine_transform_constraint_pose self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_transform_constraint_pose_set(
      self,
      pose,
    );
  }

  late final _spine_transform_constraint_pose_setPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_pose, spine_transform_constraint_pose)>>(
          'spine_transform_constraint_pose_set');
  late final _spine_transform_constraint_pose_set = _spine_transform_constraint_pose_setPtr
      .asFunction<void Function(spine_transform_constraint_pose, spine_transform_constraint_pose)>();

  /// A percentage (0-1) that controls the mix between the constrained and
  /// unconstrained rotation.
  double spine_transform_constraint_pose_get_mix_rotate(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_get_mix_rotate(
      self,
    );
  }

  late final _spine_transform_constraint_pose_get_mix_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_pose)>>(
          'spine_transform_constraint_pose_get_mix_rotate');
  late final _spine_transform_constraint_pose_get_mix_rotate =
      _spine_transform_constraint_pose_get_mix_rotatePtr.asFunction<double Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set_mix_rotate(
    spine_transform_constraint_pose self,
    double mixRotate,
  ) {
    return _spine_transform_constraint_pose_set_mix_rotate(
      self,
      mixRotate,
    );
  }

  late final _spine_transform_constraint_pose_set_mix_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_pose, ffi.Float)>>(
          'spine_transform_constraint_pose_set_mix_rotate');
  late final _spine_transform_constraint_pose_set_mix_rotate = _spine_transform_constraint_pose_set_mix_rotatePtr
      .asFunction<void Function(spine_transform_constraint_pose, double)>();

  /// A percentage (0-1) that controls the mix between the constrained and
  /// unconstrained translation X.
  double spine_transform_constraint_pose_get_mix_x(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_get_mix_x(
      self,
    );
  }

  late final _spine_transform_constraint_pose_get_mix_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_pose)>>(
          'spine_transform_constraint_pose_get_mix_x');
  late final _spine_transform_constraint_pose_get_mix_x =
      _spine_transform_constraint_pose_get_mix_xPtr.asFunction<double Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set_mix_x(
    spine_transform_constraint_pose self,
    double mixX,
  ) {
    return _spine_transform_constraint_pose_set_mix_x(
      self,
      mixX,
    );
  }

  late final _spine_transform_constraint_pose_set_mix_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_pose, ffi.Float)>>(
          'spine_transform_constraint_pose_set_mix_x');
  late final _spine_transform_constraint_pose_set_mix_x = _spine_transform_constraint_pose_set_mix_xPtr
      .asFunction<void Function(spine_transform_constraint_pose, double)>();

  /// A percentage (0-1) that controls the mix between the constrained and
  /// unconstrained translation Y.
  double spine_transform_constraint_pose_get_mix_y(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_get_mix_y(
      self,
    );
  }

  late final _spine_transform_constraint_pose_get_mix_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_pose)>>(
          'spine_transform_constraint_pose_get_mix_y');
  late final _spine_transform_constraint_pose_get_mix_y =
      _spine_transform_constraint_pose_get_mix_yPtr.asFunction<double Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set_mix_y(
    spine_transform_constraint_pose self,
    double mixY,
  ) {
    return _spine_transform_constraint_pose_set_mix_y(
      self,
      mixY,
    );
  }

  late final _spine_transform_constraint_pose_set_mix_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_pose, ffi.Float)>>(
          'spine_transform_constraint_pose_set_mix_y');
  late final _spine_transform_constraint_pose_set_mix_y = _spine_transform_constraint_pose_set_mix_yPtr
      .asFunction<void Function(spine_transform_constraint_pose, double)>();

  /// A percentage (0-1) that controls the mix between the constrained and
  /// unconstrained scale X.
  double spine_transform_constraint_pose_get_mix_scale_x(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_get_mix_scale_x(
      self,
    );
  }

  late final _spine_transform_constraint_pose_get_mix_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_pose)>>(
          'spine_transform_constraint_pose_get_mix_scale_x');
  late final _spine_transform_constraint_pose_get_mix_scale_x = _spine_transform_constraint_pose_get_mix_scale_xPtr
      .asFunction<double Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set_mix_scale_x(
    spine_transform_constraint_pose self,
    double mixScaleX,
  ) {
    return _spine_transform_constraint_pose_set_mix_scale_x(
      self,
      mixScaleX,
    );
  }

  late final _spine_transform_constraint_pose_set_mix_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_pose, ffi.Float)>>(
          'spine_transform_constraint_pose_set_mix_scale_x');
  late final _spine_transform_constraint_pose_set_mix_scale_x = _spine_transform_constraint_pose_set_mix_scale_xPtr
      .asFunction<void Function(spine_transform_constraint_pose, double)>();

  /// A percentage (0-1) that controls the mix between the constrained and
  /// unconstrained scale Y.
  double spine_transform_constraint_pose_get_mix_scale_y(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_get_mix_scale_y(
      self,
    );
  }

  late final _spine_transform_constraint_pose_get_mix_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_pose)>>(
          'spine_transform_constraint_pose_get_mix_scale_y');
  late final _spine_transform_constraint_pose_get_mix_scale_y = _spine_transform_constraint_pose_get_mix_scale_yPtr
      .asFunction<double Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set_mix_scale_y(
    spine_transform_constraint_pose self,
    double mixScaleY,
  ) {
    return _spine_transform_constraint_pose_set_mix_scale_y(
      self,
      mixScaleY,
    );
  }

  late final _spine_transform_constraint_pose_set_mix_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_pose, ffi.Float)>>(
          'spine_transform_constraint_pose_set_mix_scale_y');
  late final _spine_transform_constraint_pose_set_mix_scale_y = _spine_transform_constraint_pose_set_mix_scale_yPtr
      .asFunction<void Function(spine_transform_constraint_pose, double)>();

  /// A percentage (0-1) that controls the mix between the constrained and
  /// unconstrained shear Y.
  double spine_transform_constraint_pose_get_mix_shear_y(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_get_mix_shear_y(
      self,
    );
  }

  late final _spine_transform_constraint_pose_get_mix_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_pose)>>(
          'spine_transform_constraint_pose_get_mix_shear_y');
  late final _spine_transform_constraint_pose_get_mix_shear_y = _spine_transform_constraint_pose_get_mix_shear_yPtr
      .asFunction<double Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set_mix_shear_y(
    spine_transform_constraint_pose self,
    double mixShearY,
  ) {
    return _spine_transform_constraint_pose_set_mix_shear_y(
      self,
      mixShearY,
    );
  }

  late final _spine_transform_constraint_pose_set_mix_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_pose, ffi.Float)>>(
          'spine_transform_constraint_pose_set_mix_shear_y');
  late final _spine_transform_constraint_pose_set_mix_shear_y = _spine_transform_constraint_pose_set_mix_shear_yPtr
      .asFunction<void Function(spine_transform_constraint_pose, double)>();

  spine_transform_constraint_timeline spine_transform_constraint_timeline_create(
    int frameCount,
    int bezierCount,
    int transformConstraintIndex,
  ) {
    return _spine_transform_constraint_timeline_create(
      frameCount,
      bezierCount,
      transformConstraintIndex,
    );
  }

  late final _spine_transform_constraint_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_transform_constraint_timeline_create');
  late final _spine_transform_constraint_timeline_create = _spine_transform_constraint_timeline_createPtr
      .asFunction<spine_transform_constraint_timeline Function(int, int, int)>();

  void spine_transform_constraint_timeline_dispose(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_dispose(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_dispose');
  late final _spine_transform_constraint_timeline_dispose =
      _spine_transform_constraint_timeline_disposePtr.asFunction<void Function(spine_transform_constraint_timeline)>();

  spine_rtti spine_transform_constraint_timeline_get_rtti(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_rtti(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_get_rtti');
  late final _spine_transform_constraint_timeline_get_rtti = _spine_transform_constraint_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_transform_constraint_timeline)>();

  void spine_transform_constraint_timeline_apply(
    spine_transform_constraint_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_transform_constraint_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_transform_constraint_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_transform_constraint_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_transform_constraint_timeline_apply');
  late final _spine_transform_constraint_timeline_apply = _spine_transform_constraint_timeline_applyPtr.asFunction<
      void Function(spine_transform_constraint_timeline, spine_skeleton, double, double, spine_array_event, double, int,
          int, bool)>();

  /// Sets the time, rotate mix, translate mix, scale mix, and shear mix for the
  /// specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_transform_constraint_timeline_set_frame(
    spine_transform_constraint_timeline self,
    int frame,
    double time,
    double mixRotate,
    double mixX,
    double mixY,
    double mixScaleX,
    double mixScaleY,
    double mixShearY,
  ) {
    return _spine_transform_constraint_timeline_set_frame(
      self,
      frame,
      time,
      mixRotate,
      mixX,
      mixY,
      mixScaleX,
      mixScaleY,
      mixShearY,
    );
  }

  late final _spine_transform_constraint_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_timeline, ffi.Int, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float)>>('spine_transform_constraint_timeline_set_frame');
  late final _spine_transform_constraint_timeline_set_frame =
      _spine_transform_constraint_timeline_set_framePtr.asFunction<
          void Function(
              spine_transform_constraint_timeline, int, double, double, double, double, double, double, double)>();

  int spine_transform_constraint_timeline_get_constraint_index(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_get_constraint_index');
  late final _spine_transform_constraint_timeline_get_constraint_index =
      _spine_transform_constraint_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_transform_constraint_timeline)>();

  void spine_transform_constraint_timeline_set_constraint_index(
    spine_transform_constraint_timeline self,
    int inValue,
  ) {
    return _spine_transform_constraint_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_transform_constraint_timeline_set_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_timeline, ffi.Int)>>(
          'spine_transform_constraint_timeline_set_constraint_index');
  late final _spine_transform_constraint_timeline_set_constraint_index =
      _spine_transform_constraint_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_transform_constraint_timeline, int)>();

  void spine_transform_constraint_timeline_set_linear(
    spine_transform_constraint_timeline self,
    int frame,
  ) {
    return _spine_transform_constraint_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_transform_constraint_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_timeline, ffi.Size)>>(
          'spine_transform_constraint_timeline_set_linear');
  late final _spine_transform_constraint_timeline_set_linear = _spine_transform_constraint_timeline_set_linearPtr
      .asFunction<void Function(spine_transform_constraint_timeline, int)>();

  void spine_transform_constraint_timeline_set_stepped(
    spine_transform_constraint_timeline self,
    int frame,
  ) {
    return _spine_transform_constraint_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_transform_constraint_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_timeline, ffi.Size)>>(
          'spine_transform_constraint_timeline_set_stepped');
  late final _spine_transform_constraint_timeline_set_stepped = _spine_transform_constraint_timeline_set_steppedPtr
      .asFunction<void Function(spine_transform_constraint_timeline, int)>();

  void spine_transform_constraint_timeline_set_bezier(
    spine_transform_constraint_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_transform_constraint_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_transform_constraint_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_transform_constraint_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_transform_constraint_timeline_set_bezier');
  late final _spine_transform_constraint_timeline_set_bezier =
      _spine_transform_constraint_timeline_set_bezierPtr.asFunction<
          void Function(spine_transform_constraint_timeline, int, int, double, double, double, double, double, double,
              double, double, double)>();

  double spine_transform_constraint_timeline_get_bezier_value(
    spine_transform_constraint_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_transform_constraint_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_transform_constraint_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_transform_constraint_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_transform_constraint_timeline_get_bezier_value');
  late final _spine_transform_constraint_timeline_get_bezier_value =
      _spine_transform_constraint_timeline_get_bezier_valuePtr
          .asFunction<double Function(spine_transform_constraint_timeline, double, int, int, int)>();

  spine_array_float spine_transform_constraint_timeline_get_curves(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_curves(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_get_curves');
  late final _spine_transform_constraint_timeline_get_curves = _spine_transform_constraint_timeline_get_curvesPtr
      .asFunction<spine_array_float Function(spine_transform_constraint_timeline)>();

  int spine_transform_constraint_timeline_get_frame_entries(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_get_frame_entries');
  late final _spine_transform_constraint_timeline_get_frame_entries =
      _spine_transform_constraint_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_transform_constraint_timeline)>();

  int spine_transform_constraint_timeline_get_frame_count(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_get_frame_count');
  late final _spine_transform_constraint_timeline_get_frame_count =
      _spine_transform_constraint_timeline_get_frame_countPtr
          .asFunction<int Function(spine_transform_constraint_timeline)>();

  spine_array_float spine_transform_constraint_timeline_get_frames(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_frames(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_get_frames');
  late final _spine_transform_constraint_timeline_get_frames = _spine_transform_constraint_timeline_get_framesPtr
      .asFunction<spine_array_float Function(spine_transform_constraint_timeline)>();

  double spine_transform_constraint_timeline_get_duration(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_duration(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_get_duration');
  late final _spine_transform_constraint_timeline_get_duration = _spine_transform_constraint_timeline_get_durationPtr
      .asFunction<double Function(spine_transform_constraint_timeline)>();

  spine_array_property_id spine_transform_constraint_timeline_get_property_ids(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_get_property_ids');
  late final _spine_transform_constraint_timeline_get_property_ids =
      _spine_transform_constraint_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_transform_constraint_timeline)>();

  spine_rtti spine_transform_constraint_timeline_rtti() {
    return _spine_transform_constraint_timeline_rtti();
  }

  late final _spine_transform_constraint_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_transform_constraint_timeline_rtti');
  late final _spine_transform_constraint_timeline_rtti =
      _spine_transform_constraint_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_translate_timeline spine_translate_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_translate_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_translate_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_translate_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_translate_timeline_create');
  late final _spine_translate_timeline_create =
      _spine_translate_timeline_createPtr.asFunction<spine_translate_timeline Function(int, int, int)>();

  void spine_translate_timeline_dispose(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_dispose(
      self,
    );
  }

  late final _spine_translate_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_timeline)>>('spine_translate_timeline_dispose');
  late final _spine_translate_timeline_dispose =
      _spine_translate_timeline_disposePtr.asFunction<void Function(spine_translate_timeline)>();

  spine_rtti spine_translate_timeline_get_rtti(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_rtti(
      self,
    );
  }

  late final _spine_translate_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_translate_timeline)>>('spine_translate_timeline_get_rtti');
  late final _spine_translate_timeline_get_rtti =
      _spine_translate_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_translate_timeline)>();

  void spine_translate_timeline_apply(
    spine_translate_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_translate_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_translate_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event,
              ffi.Float, ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_translate_timeline_apply');
  late final _spine_translate_timeline_apply = _spine_translate_timeline_applyPtr.asFunction<
      void Function(
          spine_translate_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_translate_timeline_get_bone_index(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_translate_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_translate_timeline)>>(
          'spine_translate_timeline_get_bone_index');
  late final _spine_translate_timeline_get_bone_index =
      _spine_translate_timeline_get_bone_indexPtr.asFunction<int Function(spine_translate_timeline)>();

  void spine_translate_timeline_set_bone_index(
    spine_translate_timeline self,
    int inValue,
  ) {
    return _spine_translate_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_translate_timeline_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_timeline, ffi.Int)>>(
          'spine_translate_timeline_set_bone_index');
  late final _spine_translate_timeline_set_bone_index =
      _spine_translate_timeline_set_bone_indexPtr.asFunction<void Function(spine_translate_timeline, int)>();

  void spine_translate_timeline_set_frame(
    spine_translate_timeline self,
    int frame,
    double time,
    double value1,
    double value2,
  ) {
    return _spine_translate_timeline_set_frame(
      self,
      frame,
      time,
      value1,
      value2,
    );
  }

  late final _spine_translate_timeline_set_framePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_translate_timeline, ffi.Size, ffi.Float, ffi.Float, ffi.Float)>>(
      'spine_translate_timeline_set_frame');
  late final _spine_translate_timeline_set_frame = _spine_translate_timeline_set_framePtr
      .asFunction<void Function(spine_translate_timeline, int, double, double, double)>();

  void spine_translate_timeline_set_linear(
    spine_translate_timeline self,
    int frame,
  ) {
    return _spine_translate_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_translate_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_timeline, ffi.Size)>>(
          'spine_translate_timeline_set_linear');
  late final _spine_translate_timeline_set_linear =
      _spine_translate_timeline_set_linearPtr.asFunction<void Function(spine_translate_timeline, int)>();

  void spine_translate_timeline_set_stepped(
    spine_translate_timeline self,
    int frame,
  ) {
    return _spine_translate_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_translate_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_timeline, ffi.Size)>>(
          'spine_translate_timeline_set_stepped');
  late final _spine_translate_timeline_set_stepped =
      _spine_translate_timeline_set_steppedPtr.asFunction<void Function(spine_translate_timeline, int)>();

  void spine_translate_timeline_set_bezier(
    spine_translate_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_translate_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_translate_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_translate_timeline_set_bezier');
  late final _spine_translate_timeline_set_bezier = _spine_translate_timeline_set_bezierPtr.asFunction<
      void Function(spine_translate_timeline, int, int, double, double, double, double, double, double, double, double,
          double)>();

  double spine_translate_timeline_get_bezier_value(
    spine_translate_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_translate_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_translate_timeline_get_bezier_valuePtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_translate_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
      'spine_translate_timeline_get_bezier_value');
  late final _spine_translate_timeline_get_bezier_value = _spine_translate_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_translate_timeline, double, int, int, int)>();

  spine_array_float spine_translate_timeline_get_curves(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_curves(
      self,
    );
  }

  late final _spine_translate_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_translate_timeline)>>(
          'spine_translate_timeline_get_curves');
  late final _spine_translate_timeline_get_curves =
      _spine_translate_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_translate_timeline)>();

  int spine_translate_timeline_get_frame_entries(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_translate_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_translate_timeline)>>(
          'spine_translate_timeline_get_frame_entries');
  late final _spine_translate_timeline_get_frame_entries =
      _spine_translate_timeline_get_frame_entriesPtr.asFunction<int Function(spine_translate_timeline)>();

  int spine_translate_timeline_get_frame_count(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_translate_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_translate_timeline)>>(
          'spine_translate_timeline_get_frame_count');
  late final _spine_translate_timeline_get_frame_count =
      _spine_translate_timeline_get_frame_countPtr.asFunction<int Function(spine_translate_timeline)>();

  spine_array_float spine_translate_timeline_get_frames(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_frames(
      self,
    );
  }

  late final _spine_translate_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_translate_timeline)>>(
          'spine_translate_timeline_get_frames');
  late final _spine_translate_timeline_get_frames =
      _spine_translate_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_translate_timeline)>();

  double spine_translate_timeline_get_duration(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_duration(
      self,
    );
  }

  late final _spine_translate_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_translate_timeline)>>(
          'spine_translate_timeline_get_duration');
  late final _spine_translate_timeline_get_duration =
      _spine_translate_timeline_get_durationPtr.asFunction<double Function(spine_translate_timeline)>();

  spine_array_property_id spine_translate_timeline_get_property_ids(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_translate_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_translate_timeline)>>(
          'spine_translate_timeline_get_property_ids');
  late final _spine_translate_timeline_get_property_ids = _spine_translate_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_translate_timeline)>();

  spine_rtti spine_translate_timeline_rtti() {
    return _spine_translate_timeline_rtti();
  }

  late final _spine_translate_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_translate_timeline_rtti');
  late final _spine_translate_timeline_rtti = _spine_translate_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_translate_x_timeline spine_translate_x_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_translate_x_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_translate_x_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_translate_x_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_translate_x_timeline_create');
  late final _spine_translate_x_timeline_create =
      _spine_translate_x_timeline_createPtr.asFunction<spine_translate_x_timeline Function(int, int, int)>();

  void spine_translate_x_timeline_dispose(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_dispose(
      self,
    );
  }

  late final _spine_translate_x_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_x_timeline)>>('spine_translate_x_timeline_dispose');
  late final _spine_translate_x_timeline_dispose =
      _spine_translate_x_timeline_disposePtr.asFunction<void Function(spine_translate_x_timeline)>();

  spine_rtti spine_translate_x_timeline_get_rtti(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_rtti(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_get_rtti');
  late final _spine_translate_x_timeline_get_rtti =
      _spine_translate_x_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_translate_x_timeline)>();

  void spine_translate_x_timeline_apply(
    spine_translate_x_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_translate_x_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_translate_x_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_x_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event,
              ffi.Float, ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_translate_x_timeline_apply');
  late final _spine_translate_x_timeline_apply = _spine_translate_x_timeline_applyPtr.asFunction<
      void Function(
          spine_translate_x_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_translate_x_timeline_get_bone_index(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_get_bone_index');
  late final _spine_translate_x_timeline_get_bone_index =
      _spine_translate_x_timeline_get_bone_indexPtr.asFunction<int Function(spine_translate_x_timeline)>();

  void spine_translate_x_timeline_set_bone_index(
    spine_translate_x_timeline self,
    int inValue,
  ) {
    return _spine_translate_x_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_translate_x_timeline_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_x_timeline, ffi.Int)>>(
          'spine_translate_x_timeline_set_bone_index');
  late final _spine_translate_x_timeline_set_bone_index =
      _spine_translate_x_timeline_set_bone_indexPtr.asFunction<void Function(spine_translate_x_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_translate_x_timeline_set_frame(
    spine_translate_x_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_translate_x_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_translate_x_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_x_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_translate_x_timeline_set_frame');
  late final _spine_translate_x_timeline_set_frame = _spine_translate_x_timeline_set_framePtr
      .asFunction<void Function(spine_translate_x_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_translate_x_timeline_get_curve_value(
    spine_translate_x_timeline self,
    double time,
  ) {
    return _spine_translate_x_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_translate_x_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_translate_x_timeline, ffi.Float)>>(
          'spine_translate_x_timeline_get_curve_value');
  late final _spine_translate_x_timeline_get_curve_value =
      _spine_translate_x_timeline_get_curve_valuePtr.asFunction<double Function(spine_translate_x_timeline, double)>();

  double spine_translate_x_timeline_get_relative_value(
    spine_translate_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_translate_x_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_translate_x_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_translate_x_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_translate_x_timeline_get_relative_value');
  late final _spine_translate_x_timeline_get_relative_value = _spine_translate_x_timeline_get_relative_valuePtr
      .asFunction<double Function(spine_translate_x_timeline, double, double, int, double, double)>();

  double spine_translate_x_timeline_get_absolute_value_1(
    spine_translate_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_translate_x_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_translate_x_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_translate_x_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_translate_x_timeline_get_absolute_value_1');
  late final _spine_translate_x_timeline_get_absolute_value_1 = _spine_translate_x_timeline_get_absolute_value_1Ptr
      .asFunction<double Function(spine_translate_x_timeline, double, double, int, double, double)>();

  double spine_translate_x_timeline_get_absolute_value_2(
    spine_translate_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_translate_x_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_translate_x_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_translate_x_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_translate_x_timeline_get_absolute_value_2');
  late final _spine_translate_x_timeline_get_absolute_value_2 = _spine_translate_x_timeline_get_absolute_value_2Ptr
      .asFunction<double Function(spine_translate_x_timeline, double, double, int, double, double, double)>();

  double spine_translate_x_timeline_get_scale_value(
    spine_translate_x_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_translate_x_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_translate_x_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_translate_x_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_translate_x_timeline_get_scale_value');
  late final _spine_translate_x_timeline_get_scale_value = _spine_translate_x_timeline_get_scale_valuePtr
      .asFunction<double Function(spine_translate_x_timeline, double, double, int, int, double, double)>();

  void spine_translate_x_timeline_set_linear(
    spine_translate_x_timeline self,
    int frame,
  ) {
    return _spine_translate_x_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_translate_x_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_x_timeline, ffi.Size)>>(
          'spine_translate_x_timeline_set_linear');
  late final _spine_translate_x_timeline_set_linear =
      _spine_translate_x_timeline_set_linearPtr.asFunction<void Function(spine_translate_x_timeline, int)>();

  void spine_translate_x_timeline_set_stepped(
    spine_translate_x_timeline self,
    int frame,
  ) {
    return _spine_translate_x_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_translate_x_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_x_timeline, ffi.Size)>>(
          'spine_translate_x_timeline_set_stepped');
  late final _spine_translate_x_timeline_set_stepped =
      _spine_translate_x_timeline_set_steppedPtr.asFunction<void Function(spine_translate_x_timeline, int)>();

  void spine_translate_x_timeline_set_bezier(
    spine_translate_x_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_translate_x_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_translate_x_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_x_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_translate_x_timeline_set_bezier');
  late final _spine_translate_x_timeline_set_bezier = _spine_translate_x_timeline_set_bezierPtr.asFunction<
      void Function(spine_translate_x_timeline, int, int, double, double, double, double, double, double, double,
          double, double)>();

  double spine_translate_x_timeline_get_bezier_value(
    spine_translate_x_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_translate_x_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_translate_x_timeline_get_bezier_valuePtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_translate_x_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
      'spine_translate_x_timeline_get_bezier_value');
  late final _spine_translate_x_timeline_get_bezier_value = _spine_translate_x_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_translate_x_timeline, double, int, int, int)>();

  spine_array_float spine_translate_x_timeline_get_curves(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_curves(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_get_curves');
  late final _spine_translate_x_timeline_get_curves =
      _spine_translate_x_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_translate_x_timeline)>();

  int spine_translate_x_timeline_get_frame_entries(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_get_frame_entries');
  late final _spine_translate_x_timeline_get_frame_entries =
      _spine_translate_x_timeline_get_frame_entriesPtr.asFunction<int Function(spine_translate_x_timeline)>();

  int spine_translate_x_timeline_get_frame_count(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_get_frame_count');
  late final _spine_translate_x_timeline_get_frame_count =
      _spine_translate_x_timeline_get_frame_countPtr.asFunction<int Function(spine_translate_x_timeline)>();

  spine_array_float spine_translate_x_timeline_get_frames(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_frames(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_get_frames');
  late final _spine_translate_x_timeline_get_frames =
      _spine_translate_x_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_translate_x_timeline)>();

  double spine_translate_x_timeline_get_duration(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_duration(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_get_duration');
  late final _spine_translate_x_timeline_get_duration =
      _spine_translate_x_timeline_get_durationPtr.asFunction<double Function(spine_translate_x_timeline)>();

  spine_array_property_id spine_translate_x_timeline_get_property_ids(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_get_property_ids');
  late final _spine_translate_x_timeline_get_property_ids = _spine_translate_x_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_translate_x_timeline)>();

  spine_rtti spine_translate_x_timeline_rtti() {
    return _spine_translate_x_timeline_rtti();
  }

  late final _spine_translate_x_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_translate_x_timeline_rtti');
  late final _spine_translate_x_timeline_rtti = _spine_translate_x_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_translate_y_timeline spine_translate_y_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_translate_y_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_translate_y_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_translate_y_timeline Function(ffi.Size, ffi.Size, ffi.Int)>>(
          'spine_translate_y_timeline_create');
  late final _spine_translate_y_timeline_create =
      _spine_translate_y_timeline_createPtr.asFunction<spine_translate_y_timeline Function(int, int, int)>();

  void spine_translate_y_timeline_dispose(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_dispose(
      self,
    );
  }

  late final _spine_translate_y_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_y_timeline)>>('spine_translate_y_timeline_dispose');
  late final _spine_translate_y_timeline_dispose =
      _spine_translate_y_timeline_disposePtr.asFunction<void Function(spine_translate_y_timeline)>();

  spine_rtti spine_translate_y_timeline_get_rtti(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_rtti(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_get_rtti');
  late final _spine_translate_y_timeline_get_rtti =
      _spine_translate_y_timeline_get_rttiPtr.asFunction<spine_rtti Function(spine_translate_y_timeline)>();

  void spine_translate_y_timeline_apply(
    spine_translate_y_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event events,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_translate_y_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      events,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_translate_y_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_y_timeline, spine_skeleton, ffi.Float, ffi.Float, spine_array_event,
              ffi.Float, ffi.Int32, ffi.Int32, ffi.Bool)>>('spine_translate_y_timeline_apply');
  late final _spine_translate_y_timeline_apply = _spine_translate_y_timeline_applyPtr.asFunction<
      void Function(
          spine_translate_y_timeline, spine_skeleton, double, double, spine_array_event, double, int, int, bool)>();

  int spine_translate_y_timeline_get_bone_index(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_get_bone_index');
  late final _spine_translate_y_timeline_get_bone_index =
      _spine_translate_y_timeline_get_bone_indexPtr.asFunction<int Function(spine_translate_y_timeline)>();

  void spine_translate_y_timeline_set_bone_index(
    spine_translate_y_timeline self,
    int inValue,
  ) {
    return _spine_translate_y_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_translate_y_timeline_set_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_y_timeline, ffi.Int)>>(
          'spine_translate_y_timeline_set_bone_index');
  late final _spine_translate_y_timeline_set_bone_index =
      _spine_translate_y_timeline_set_bone_indexPtr.asFunction<void Function(spine_translate_y_timeline, int)>();

  /// Sets the time and value for the specified frame.
  ///
  /// @param frame Between 0 and frameCount, inclusive.
  /// @param time The frame time in seconds.
  void spine_translate_y_timeline_set_frame(
    spine_translate_y_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_translate_y_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_translate_y_timeline_set_framePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_y_timeline, ffi.Size, ffi.Float, ffi.Float)>>(
          'spine_translate_y_timeline_set_frame');
  late final _spine_translate_y_timeline_set_frame = _spine_translate_y_timeline_set_framePtr
      .asFunction<void Function(spine_translate_y_timeline, int, double, double)>();

  /// Returns the interpolated value for the specified time.
  double spine_translate_y_timeline_get_curve_value(
    spine_translate_y_timeline self,
    double time,
  ) {
    return _spine_translate_y_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_translate_y_timeline_get_curve_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_translate_y_timeline, ffi.Float)>>(
          'spine_translate_y_timeline_get_curve_value');
  late final _spine_translate_y_timeline_get_curve_value =
      _spine_translate_y_timeline_get_curve_valuePtr.asFunction<double Function(spine_translate_y_timeline, double)>();

  double spine_translate_y_timeline_get_relative_value(
    spine_translate_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_translate_y_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_translate_y_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_translate_y_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_translate_y_timeline_get_relative_value');
  late final _spine_translate_y_timeline_get_relative_value = _spine_translate_y_timeline_get_relative_valuePtr
      .asFunction<double Function(spine_translate_y_timeline, double, double, int, double, double)>();

  double spine_translate_y_timeline_get_absolute_value_1(
    spine_translate_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_translate_y_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_translate_y_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_translate_y_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_translate_y_timeline_get_absolute_value_1');
  late final _spine_translate_y_timeline_get_absolute_value_1 = _spine_translate_y_timeline_get_absolute_value_1Ptr
      .asFunction<double Function(spine_translate_y_timeline, double, double, int, double, double)>();

  double spine_translate_y_timeline_get_absolute_value_2(
    spine_translate_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_translate_y_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_translate_y_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_translate_y_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_translate_y_timeline_get_absolute_value_2');
  late final _spine_translate_y_timeline_get_absolute_value_2 = _spine_translate_y_timeline_get_absolute_value_2Ptr
      .asFunction<double Function(spine_translate_y_timeline, double, double, int, double, double, double)>();

  double spine_translate_y_timeline_get_scale_value(
    spine_translate_y_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_translate_y_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_translate_y_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_translate_y_timeline, ffi.Float, ffi.Float, ffi.Int32, ffi.Int32, ffi.Float,
              ffi.Float)>>('spine_translate_y_timeline_get_scale_value');
  late final _spine_translate_y_timeline_get_scale_value = _spine_translate_y_timeline_get_scale_valuePtr
      .asFunction<double Function(spine_translate_y_timeline, double, double, int, int, double, double)>();

  void spine_translate_y_timeline_set_linear(
    spine_translate_y_timeline self,
    int frame,
  ) {
    return _spine_translate_y_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_translate_y_timeline_set_linearPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_y_timeline, ffi.Size)>>(
          'spine_translate_y_timeline_set_linear');
  late final _spine_translate_y_timeline_set_linear =
      _spine_translate_y_timeline_set_linearPtr.asFunction<void Function(spine_translate_y_timeline, int)>();

  void spine_translate_y_timeline_set_stepped(
    spine_translate_y_timeline self,
    int frame,
  ) {
    return _spine_translate_y_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_translate_y_timeline_set_steppedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_y_timeline, ffi.Size)>>(
          'spine_translate_y_timeline_set_stepped');
  late final _spine_translate_y_timeline_set_stepped =
      _spine_translate_y_timeline_set_steppedPtr.asFunction<void Function(spine_translate_y_timeline, int)>();

  void spine_translate_y_timeline_set_bezier(
    spine_translate_y_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_translate_y_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_translate_y_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_y_timeline, ffi.Size, ffi.Size, ffi.Float, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>('spine_translate_y_timeline_set_bezier');
  late final _spine_translate_y_timeline_set_bezier = _spine_translate_y_timeline_set_bezierPtr.asFunction<
      void Function(spine_translate_y_timeline, int, int, double, double, double, double, double, double, double,
          double, double)>();

  double spine_translate_y_timeline_get_bezier_value(
    spine_translate_y_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_translate_y_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_translate_y_timeline_get_bezier_valuePtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_translate_y_timeline, ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
      'spine_translate_y_timeline_get_bezier_value');
  late final _spine_translate_y_timeline_get_bezier_value = _spine_translate_y_timeline_get_bezier_valuePtr
      .asFunction<double Function(spine_translate_y_timeline, double, int, int, int)>();

  spine_array_float spine_translate_y_timeline_get_curves(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_curves(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_curvesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_get_curves');
  late final _spine_translate_y_timeline_get_curves =
      _spine_translate_y_timeline_get_curvesPtr.asFunction<spine_array_float Function(spine_translate_y_timeline)>();

  int spine_translate_y_timeline_get_frame_entries(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_get_frame_entries');
  late final _spine_translate_y_timeline_get_frame_entries =
      _spine_translate_y_timeline_get_frame_entriesPtr.asFunction<int Function(spine_translate_y_timeline)>();

  int spine_translate_y_timeline_get_frame_count(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_get_frame_count');
  late final _spine_translate_y_timeline_get_frame_count =
      _spine_translate_y_timeline_get_frame_countPtr.asFunction<int Function(spine_translate_y_timeline)>();

  spine_array_float spine_translate_y_timeline_get_frames(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_frames(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_get_frames');
  late final _spine_translate_y_timeline_get_frames =
      _spine_translate_y_timeline_get_framesPtr.asFunction<spine_array_float Function(spine_translate_y_timeline)>();

  double spine_translate_y_timeline_get_duration(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_duration(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_get_duration');
  late final _spine_translate_y_timeline_get_duration =
      _spine_translate_y_timeline_get_durationPtr.asFunction<double Function(spine_translate_y_timeline)>();

  spine_array_property_id spine_translate_y_timeline_get_property_ids(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_property_idsPtr =
      _lookup<ffi.NativeFunction<spine_array_property_id Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_get_property_ids');
  late final _spine_translate_y_timeline_get_property_ids = _spine_translate_y_timeline_get_property_idsPtr
      .asFunction<spine_array_property_id Function(spine_translate_y_timeline)>();

  spine_rtti spine_translate_y_timeline_rtti() {
    return _spine_translate_y_timeline_rtti();
  }

  late final _spine_translate_y_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_translate_y_timeline_rtti');
  late final _spine_translate_y_timeline_rtti = _spine_translate_y_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_update_dispose(
    spine_update self,
  ) {
    return _spine_update_dispose(
      self,
    );
  }

  late final _spine_update_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_update)>>('spine_update_dispose');
  late final _spine_update_dispose = _spine_update_disposePtr.asFunction<void Function(spine_update)>();

  spine_rtti spine_update_get_rtti(
    spine_update self,
  ) {
    return _spine_update_get_rtti(
      self,
    );
  }

  late final _spine_update_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_update)>>('spine_update_get_rtti');
  late final _spine_update_get_rtti = _spine_update_get_rttiPtr.asFunction<spine_rtti Function(spine_update)>();

  /// @param physics Determines how physics and other non-deterministic updates are applied.
  void spine_update_update(
    spine_update self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_update_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_update_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_update, spine_skeleton, ffi.Int32)>>('spine_update_update');
  late final _spine_update_update =
      _spine_update_updatePtr.asFunction<void Function(spine_update, spine_skeleton, int)>();

  spine_rtti spine_update_rtti() {
    return _spine_update_rtti();
  }

  late final _spine_update_rttiPtr = _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_update_rtti');
  late final _spine_update_rtti = _spine_update_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_vertex_attachment_dispose(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_dispose(
      self,
    );
  }

  late final _spine_vertex_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment)>>('spine_vertex_attachment_dispose');
  late final _spine_vertex_attachment_dispose =
      _spine_vertex_attachment_disposePtr.asFunction<void Function(spine_vertex_attachment)>();

  spine_rtti spine_vertex_attachment_get_rtti(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_rtti(
      self,
    );
  }

  late final _spine_vertex_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_vertex_attachment)>>('spine_vertex_attachment_get_rtti');
  late final _spine_vertex_attachment_get_rtti =
      _spine_vertex_attachment_get_rttiPtr.asFunction<spine_rtti Function(spine_vertex_attachment)>();

  /// Transforms the attachment's local vertices to world coordinates. If the
  /// slot's SlotPose::getDeform() is not empty, it is used to deform the vertices.
  ///
  /// See https://esotericsoftware.com/spine-runtime-skeletons#World-transforms
  /// World transforms in the Spine Runtimes Guide.
  ///
  /// @param start The index of the first vertices value to transform. Each vertex has 2 values, x and y.
  /// @param count The number of world vertex values to output. Must be < = WorldVerticesLength - start.
  /// @param worldVertices The output world vertices. Must have a length >= offset + count * stride / 2.
  /// @param offset The worldVertices index to begin writing values.
  /// @param stride The number of worldVertices entries between the value pairs written.
  void spine_vertex_attachment_compute_world_vertices_1(
    spine_vertex_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    ffi.Pointer<ffi.Float> worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_vertex_attachment_compute_world_vertices_1(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_vertex_attachment_compute_world_vertices_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_vertex_attachment, spine_skeleton, spine_slot, ffi.Size, ffi.Size,
              ffi.Pointer<ffi.Float>, ffi.Size, ffi.Size)>>('spine_vertex_attachment_compute_world_vertices_1');
  late final _spine_vertex_attachment_compute_world_vertices_1 =
      _spine_vertex_attachment_compute_world_vertices_1Ptr.asFunction<
          void Function(
              spine_vertex_attachment, spine_skeleton, spine_slot, int, int, ffi.Pointer<ffi.Float>, int, int)>();

  void spine_vertex_attachment_compute_world_vertices_2(
    spine_vertex_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    spine_array_float worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_vertex_attachment_compute_world_vertices_2(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_vertex_attachment_compute_world_vertices_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_vertex_attachment, spine_skeleton, spine_slot, ffi.Size, ffi.Size, spine_array_float,
              ffi.Size, ffi.Size)>>('spine_vertex_attachment_compute_world_vertices_2');
  late final _spine_vertex_attachment_compute_world_vertices_2 =
      _spine_vertex_attachment_compute_world_vertices_2Ptr.asFunction<
          void Function(spine_vertex_attachment, spine_skeleton, spine_slot, int, int, spine_array_float, int, int)>();

  /// Gets a unique ID for this attachment.
  int spine_vertex_attachment_get_id(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_id(
      self,
    );
  }

  late final _spine_vertex_attachment_get_idPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_vertex_attachment)>>('spine_vertex_attachment_get_id');
  late final _spine_vertex_attachment_get_id =
      _spine_vertex_attachment_get_idPtr.asFunction<int Function(spine_vertex_attachment)>();

  spine_array_int spine_vertex_attachment_get_bones(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_bones(
      self,
    );
  }

  late final _spine_vertex_attachment_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_int Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_get_bones');
  late final _spine_vertex_attachment_get_bones =
      _spine_vertex_attachment_get_bonesPtr.asFunction<spine_array_int Function(spine_vertex_attachment)>();

  void spine_vertex_attachment_set_bones(
    spine_vertex_attachment self,
    spine_array_int bones,
  ) {
    return _spine_vertex_attachment_set_bones(
      self,
      bones,
    );
  }

  late final _spine_vertex_attachment_set_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment, spine_array_int)>>(
          'spine_vertex_attachment_set_bones');
  late final _spine_vertex_attachment_set_bones =
      _spine_vertex_attachment_set_bonesPtr.asFunction<void Function(spine_vertex_attachment, spine_array_int)>();

  spine_array_float spine_vertex_attachment_get_vertices(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_vertices(
      self,
    );
  }

  late final _spine_vertex_attachment_get_verticesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_get_vertices');
  late final _spine_vertex_attachment_get_vertices =
      _spine_vertex_attachment_get_verticesPtr.asFunction<spine_array_float Function(spine_vertex_attachment)>();

  void spine_vertex_attachment_set_vertices(
    spine_vertex_attachment self,
    spine_array_float vertices,
  ) {
    return _spine_vertex_attachment_set_vertices(
      self,
      vertices,
    );
  }

  late final _spine_vertex_attachment_set_verticesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment, spine_array_float)>>(
          'spine_vertex_attachment_set_vertices');
  late final _spine_vertex_attachment_set_vertices =
      _spine_vertex_attachment_set_verticesPtr.asFunction<void Function(spine_vertex_attachment, spine_array_float)>();

  int spine_vertex_attachment_get_world_vertices_length(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_world_vertices_length(
      self,
    );
  }

  late final _spine_vertex_attachment_get_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_get_world_vertices_length');
  late final _spine_vertex_attachment_get_world_vertices_length =
      _spine_vertex_attachment_get_world_vertices_lengthPtr.asFunction<int Function(spine_vertex_attachment)>();

  void spine_vertex_attachment_set_world_vertices_length(
    spine_vertex_attachment self,
    int inValue,
  ) {
    return _spine_vertex_attachment_set_world_vertices_length(
      self,
      inValue,
    );
  }

  late final _spine_vertex_attachment_set_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment, ffi.Size)>>(
          'spine_vertex_attachment_set_world_vertices_length');
  late final _spine_vertex_attachment_set_world_vertices_length =
      _spine_vertex_attachment_set_world_vertices_lengthPtr.asFunction<void Function(spine_vertex_attachment, int)>();

  spine_attachment spine_vertex_attachment_get_timeline_attachment(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_timeline_attachment(
      self,
    );
  }

  late final _spine_vertex_attachment_get_timeline_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_get_timeline_attachment');
  late final _spine_vertex_attachment_get_timeline_attachment = _spine_vertex_attachment_get_timeline_attachmentPtr
      .asFunction<spine_attachment Function(spine_vertex_attachment)>();

  void spine_vertex_attachment_set_timeline_attachment(
    spine_vertex_attachment self,
    spine_attachment attachment,
  ) {
    return _spine_vertex_attachment_set_timeline_attachment(
      self,
      attachment,
    );
  }

  late final _spine_vertex_attachment_set_timeline_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment, spine_attachment)>>(
          'spine_vertex_attachment_set_timeline_attachment');
  late final _spine_vertex_attachment_set_timeline_attachment = _spine_vertex_attachment_set_timeline_attachmentPtr
      .asFunction<void Function(spine_vertex_attachment, spine_attachment)>();

  void spine_vertex_attachment_copy_to(
    spine_vertex_attachment self,
    spine_vertex_attachment other,
  ) {
    return _spine_vertex_attachment_copy_to(
      self,
      other,
    );
  }

  late final _spine_vertex_attachment_copy_toPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment, spine_vertex_attachment)>>(
          'spine_vertex_attachment_copy_to');
  late final _spine_vertex_attachment_copy_to =
      _spine_vertex_attachment_copy_toPtr.asFunction<void Function(spine_vertex_attachment, spine_vertex_attachment)>();

  ffi.Pointer<ffi.Char> spine_vertex_attachment_get_name(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_name(
      self,
    );
  }

  late final _spine_vertex_attachment_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_get_name');
  late final _spine_vertex_attachment_get_name =
      _spine_vertex_attachment_get_namePtr.asFunction<ffi.Pointer<ffi.Char> Function(spine_vertex_attachment)>();

  spine_attachment spine_vertex_attachment_copy(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_copy(
      self,
    );
  }

  late final _spine_vertex_attachment_copyPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_vertex_attachment)>>('spine_vertex_attachment_copy');
  late final _spine_vertex_attachment_copy =
      _spine_vertex_attachment_copyPtr.asFunction<spine_attachment Function(spine_vertex_attachment)>();

  int spine_vertex_attachment_get_ref_count(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_vertex_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_vertex_attachment)>>('spine_vertex_attachment_get_ref_count');
  late final _spine_vertex_attachment_get_ref_count =
      _spine_vertex_attachment_get_ref_countPtr.asFunction<int Function(spine_vertex_attachment)>();

  void spine_vertex_attachment_reference(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_reference(
      self,
    );
  }

  late final _spine_vertex_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment)>>('spine_vertex_attachment_reference');
  late final _spine_vertex_attachment_reference =
      _spine_vertex_attachment_referencePtr.asFunction<void Function(spine_vertex_attachment)>();

  void spine_vertex_attachment_dereference(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_dereference(
      self,
    );
  }

  late final _spine_vertex_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment)>>('spine_vertex_attachment_dereference');
  late final _spine_vertex_attachment_dereference =
      _spine_vertex_attachment_dereferencePtr.asFunction<void Function(spine_vertex_attachment)>();

  spine_rtti spine_vertex_attachment_rtti() {
    return _spine_vertex_attachment_rtti();
  }

  late final _spine_vertex_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_vertex_attachment_rtti');
  late final _spine_vertex_attachment_rtti = _spine_vertex_attachment_rttiPtr.asFunction<spine_rtti Function()>();
}

/// mbstate_t is an opaque object to keep conversion state, during multibyte
/// stream conversions.  The content must not be referenced by user programs.

/// Forward declarations for all non-enum types
final class spine_alpha_timeline_wrapper extends ffi.Opaque {}

final class spine_animation_wrapper extends ffi.Opaque {}

final class spine_animation_state_wrapper extends ffi.Opaque {}

final class spine_animation_state_data_wrapper extends ffi.Opaque {}

final class spine_atlas_wrapper extends ffi.Opaque {}

final class spine_atlas_attachment_loader_wrapper extends ffi.Opaque {}

final class spine_atlas_page_wrapper extends ffi.Opaque {}

final class spine_atlas_region_wrapper extends ffi.Opaque {}

final class spine_attachment_wrapper extends ffi.Opaque {}

final class spine_attachment_loader_wrapper extends ffi.Opaque {}

final class spine_attachment_timeline_wrapper extends ffi.Opaque {}

final class spine_bone_wrapper extends ffi.Opaque {}

final class spine_bone_data_wrapper extends ffi.Opaque {}

final class spine_bone_local_wrapper extends ffi.Opaque {}

final class spine_bone_pose_wrapper extends ffi.Opaque {}

final class spine_bone_timeline_wrapper extends ffi.Opaque {}

final class spine_bone_timeline1_wrapper extends ffi.Opaque {}

final class spine_bone_timeline2_wrapper extends ffi.Opaque {}

final class spine_bounding_box_attachment_wrapper extends ffi.Opaque {}

final class spine_clipping_attachment_wrapper extends ffi.Opaque {}

final class spine_color_wrapper extends ffi.Opaque {}

final class spine_constraint_wrapper extends ffi.Opaque {}

final class spine_constraint_data_wrapper extends ffi.Opaque {}

final class spine_constraint_timeline_wrapper extends ffi.Opaque {}

final class spine_constraint_timeline1_wrapper extends ffi.Opaque {}

final class spine_curve_timeline_wrapper extends ffi.Opaque {}

final class spine_curve_timeline1_wrapper extends ffi.Opaque {}

final class spine_deform_timeline_wrapper extends ffi.Opaque {}

final class spine_draw_order_timeline_wrapper extends ffi.Opaque {}

final class spine_event_wrapper extends ffi.Opaque {}

final class spine_event_data_wrapper extends ffi.Opaque {}

final class spine_event_queue_entry_wrapper extends ffi.Opaque {}

final class spine_event_timeline_wrapper extends ffi.Opaque {}

final class spine_from_property_wrapper extends ffi.Opaque {}

final class spine_from_rotate_wrapper extends ffi.Opaque {}

final class spine_from_scale_x_wrapper extends ffi.Opaque {}

final class spine_from_scale_y_wrapper extends ffi.Opaque {}

final class spine_from_shear_y_wrapper extends ffi.Opaque {}

final class spine_from_x_wrapper extends ffi.Opaque {}

final class spine_from_y_wrapper extends ffi.Opaque {}

final class spine_ik_constraint_wrapper extends ffi.Opaque {}

final class spine_ik_constraint_base_wrapper extends ffi.Opaque {}

final class spine_ik_constraint_data_wrapper extends ffi.Opaque {}

final class spine_ik_constraint_pose_wrapper extends ffi.Opaque {}

final class spine_ik_constraint_timeline_wrapper extends ffi.Opaque {}

final class spine_inherit_timeline_wrapper extends ffi.Opaque {}

final class spine_linked_mesh_wrapper extends ffi.Opaque {}

final class spine_mesh_attachment_wrapper extends ffi.Opaque {}

final class spine_path_attachment_wrapper extends ffi.Opaque {}

final class spine_path_constraint_wrapper extends ffi.Opaque {}

final class spine_path_constraint_base_wrapper extends ffi.Opaque {}

final class spine_path_constraint_data_wrapper extends ffi.Opaque {}

final class spine_path_constraint_mix_timeline_wrapper extends ffi.Opaque {}

final class spine_path_constraint_pose_wrapper extends ffi.Opaque {}

final class spine_path_constraint_position_timeline_wrapper extends ffi.Opaque {}

final class spine_path_constraint_spacing_timeline_wrapper extends ffi.Opaque {}

final class spine_physics_constraint_wrapper extends ffi.Opaque {}

final class spine_physics_constraint_base_wrapper extends ffi.Opaque {}

final class spine_physics_constraint_damping_timeline_wrapper extends ffi.Opaque {}

final class spine_physics_constraint_data_wrapper extends ffi.Opaque {}

final class spine_physics_constraint_gravity_timeline_wrapper extends ffi.Opaque {}

final class spine_physics_constraint_inertia_timeline_wrapper extends ffi.Opaque {}

final class spine_physics_constraint_mass_timeline_wrapper extends ffi.Opaque {}

final class spine_physics_constraint_mix_timeline_wrapper extends ffi.Opaque {}

final class spine_physics_constraint_pose_wrapper extends ffi.Opaque {}

final class spine_physics_constraint_reset_timeline_wrapper extends ffi.Opaque {}

final class spine_physics_constraint_strength_timeline_wrapper extends ffi.Opaque {}

final class spine_physics_constraint_timeline_wrapper extends ffi.Opaque {}

final class spine_physics_constraint_wind_timeline_wrapper extends ffi.Opaque {}

final class spine_point_attachment_wrapper extends ffi.Opaque {}

final class spine_polygon_wrapper extends ffi.Opaque {}

final class spine_posed_wrapper extends ffi.Opaque {}

final class spine_posed_active_wrapper extends ffi.Opaque {}

final class spine_posed_data_wrapper extends ffi.Opaque {}

final class spine_region_attachment_wrapper extends ffi.Opaque {}

final class spine_render_command_wrapper extends ffi.Opaque {}

final class spine_rgb2_timeline_wrapper extends ffi.Opaque {}

final class spine_rgba2_timeline_wrapper extends ffi.Opaque {}

final class spine_rgba_timeline_wrapper extends ffi.Opaque {}

final class spine_rgb_timeline_wrapper extends ffi.Opaque {}

final class spine_rotate_timeline_wrapper extends ffi.Opaque {}

final class spine_rtti_wrapper extends ffi.Opaque {}

final class spine_scale_timeline_wrapper extends ffi.Opaque {}

final class spine_scale_x_timeline_wrapper extends ffi.Opaque {}

final class spine_scale_y_timeline_wrapper extends ffi.Opaque {}

final class spine_sequence_wrapper extends ffi.Opaque {}

final class spine_sequence_timeline_wrapper extends ffi.Opaque {}

final class spine_shear_timeline_wrapper extends ffi.Opaque {}

final class spine_shear_x_timeline_wrapper extends ffi.Opaque {}

final class spine_shear_y_timeline_wrapper extends ffi.Opaque {}

final class spine_skeleton_wrapper extends ffi.Opaque {}

final class spine_skeleton_binary_wrapper extends ffi.Opaque {}

final class spine_skeleton_bounds_wrapper extends ffi.Opaque {}

final class spine_skeleton_clipping_wrapper extends ffi.Opaque {}

final class spine_skeleton_data_wrapper extends ffi.Opaque {}

final class spine_skeleton_json_wrapper extends ffi.Opaque {}

final class spine_skeleton_renderer_wrapper extends ffi.Opaque {}

final class spine_skin_wrapper extends ffi.Opaque {}

final class spine_slider_wrapper extends ffi.Opaque {}

final class spine_slider_base_wrapper extends ffi.Opaque {}

final class spine_slider_data_wrapper extends ffi.Opaque {}

final class spine_slider_mix_timeline_wrapper extends ffi.Opaque {}

final class spine_slider_pose_wrapper extends ffi.Opaque {}

final class spine_slider_timeline_wrapper extends ffi.Opaque {}

final class spine_slot_wrapper extends ffi.Opaque {}

final class spine_slot_curve_timeline_wrapper extends ffi.Opaque {}

final class spine_slot_data_wrapper extends ffi.Opaque {}

final class spine_slot_pose_wrapper extends ffi.Opaque {}

final class spine_slot_timeline_wrapper extends ffi.Opaque {}

final class spine_texture_region_wrapper extends ffi.Opaque {}

final class spine_timeline_wrapper extends ffi.Opaque {}

final class spine_to_property_wrapper extends ffi.Opaque {}

final class spine_to_rotate_wrapper extends ffi.Opaque {}

final class spine_to_scale_x_wrapper extends ffi.Opaque {}

final class spine_to_scale_y_wrapper extends ffi.Opaque {}

final class spine_to_shear_y_wrapper extends ffi.Opaque {}

final class spine_to_x_wrapper extends ffi.Opaque {}

final class spine_to_y_wrapper extends ffi.Opaque {}

final class spine_track_entry_wrapper extends ffi.Opaque {}

final class spine_transform_constraint_wrapper extends ffi.Opaque {}

final class spine_transform_constraint_base_wrapper extends ffi.Opaque {}

final class spine_transform_constraint_data_wrapper extends ffi.Opaque {}

final class spine_transform_constraint_pose_wrapper extends ffi.Opaque {}

final class spine_transform_constraint_timeline_wrapper extends ffi.Opaque {}

final class spine_translate_timeline_wrapper extends ffi.Opaque {}

final class spine_translate_x_timeline_wrapper extends ffi.Opaque {}

final class spine_translate_y_timeline_wrapper extends ffi.Opaque {}

final class spine_update_wrapper extends ffi.Opaque {}

final class spine_vertex_attachment_wrapper extends ffi.Opaque {}

abstract class spine_attachment_type {
  static const int SPINE_ATTACHMENT_TYPE_REGION = 0;
  static const int SPINE_ATTACHMENT_TYPE_BOUNDINGBOX = 1;
  static const int SPINE_ATTACHMENT_TYPE_MESH = 2;
  static const int SPINE_ATTACHMENT_TYPE_LINKEDMESH = 3;
  static const int SPINE_ATTACHMENT_TYPE_PATH = 4;
  static const int SPINE_ATTACHMENT_TYPE_POINT = 5;
  static const int SPINE_ATTACHMENT_TYPE_CLIPPING = 6;
}

abstract class spine_blend_mode {
  static const int SPINE_BLEND_MODE_NORMAL = 0;
  static const int SPINE_BLEND_MODE_ADDITIVE = 1;
  static const int SPINE_BLEND_MODE_MULTIPLY = 2;
  static const int SPINE_BLEND_MODE_SCREEN = 3;
}

abstract class spine_event_type {
  static const int SPINE_EVENT_TYPE_START = 0;
  static const int SPINE_EVENT_TYPE_INTERRUPT = 1;
  static const int SPINE_EVENT_TYPE_END = 2;
  static const int SPINE_EVENT_TYPE_DISPOSE = 3;
  static const int SPINE_EVENT_TYPE_COMPLETE = 4;
  static const int SPINE_EVENT_TYPE_EVENT = 5;
}

abstract class spine_format {
  static const int SPINE_FORMAT_ALPHA = 0;
  static const int SPINE_FORMAT_INTENSITY = 1;
  static const int SPINE_FORMAT_LUMINANCE_ALPHA = 2;
  static const int SPINE_FORMAT_RGB565 = 3;
  static const int SPINE_FORMAT_RGBA4444 = 4;
  static const int SPINE_FORMAT_RGB888 = 5;
  static const int SPINE_FORMAT_RGBA8888 = 6;
}

abstract class spine_inherit {
  static const int SPINE_INHERIT_NORMAL = 0;
  static const int SPINE_INHERIT_ONLY_TRANSLATION = 1;
  static const int SPINE_INHERIT_NO_ROTATION_OR_REFLECTION = 2;
  static const int SPINE_INHERIT_NO_SCALE = 3;
  static const int SPINE_INHERIT_NO_SCALE_OR_REFLECTION = 4;
}

abstract class spine_mix_blend {
  static const int SPINE_MIX_BLEND_SETUP = 0;
  static const int SPINE_MIX_BLEND_FIRST = 1;
  static const int SPINE_MIX_BLEND_REPLACE = 2;
  static const int SPINE_MIX_BLEND_ADD = 3;
}

abstract class spine_mix_direction {
  static const int SPINE_MIX_DIRECTION_IN = 0;
  static const int SPINE_MIX_DIRECTION_OUT = 1;
}

abstract class spine_physics {
  static const int SPINE_PHYSICS_NONE = 0;
  static const int SPINE_PHYSICS_RESET = 1;
  static const int SPINE_PHYSICS_UPDATE = 2;
  static const int SPINE_PHYSICS_POSE = 3;
}

abstract class spine_position_mode {
  static const int SPINE_POSITION_MODE_FIXED = 0;
  static const int SPINE_POSITION_MODE_PERCENT = 1;
}

abstract class spine_property {
  static const int SPINE_PROPERTY_ROTATE = 1;
  static const int SPINE_PROPERTY_X = 2;
  static const int SPINE_PROPERTY_Y = 4;
  static const int SPINE_PROPERTY_SCALE_X = 8;
  static const int SPINE_PROPERTY_SCALE_Y = 16;
  static const int SPINE_PROPERTY_SHEAR_X = 32;
  static const int SPINE_PROPERTY_SHEAR_Y = 64;
  static const int SPINE_PROPERTY_INHERIT = 128;
  static const int SPINE_PROPERTY_RGB = 256;
  static const int SPINE_PROPERTY_ALPHA = 512;
  static const int SPINE_PROPERTY_RGB2 = 1024;
  static const int SPINE_PROPERTY_ATTACHMENT = 2048;
  static const int SPINE_PROPERTY_DEFORM = 4096;
  static const int SPINE_PROPERTY_EVENT = 8192;
  static const int SPINE_PROPERTY_DRAW_ORDER = 16384;
  static const int SPINE_PROPERTY_IK_CONSTRAINT = 32768;
  static const int SPINE_PROPERTY_TRANSFORM_CONSTRAINT = 65536;
  static const int SPINE_PROPERTY_PATH_CONSTRAINT_POSITION = 131072;
  static const int SPINE_PROPERTY_PATH_CONSTRAINT_SPACING = 262144;
  static const int SPINE_PROPERTY_PATH_CONSTRAINT_MIX = 524288;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_INERTIA = 1048576;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_STRENGTH = 2097152;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_DAMPING = 4194304;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_MASS = 8388608;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_WIND = 16777216;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_GRAVITY = 33554432;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_MIX = 67108864;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_RESET = 134217728;
  static const int SPINE_PROPERTY_SEQUENCE = 268435456;
  static const int SPINE_PROPERTY_SLIDER_TIME = 536870912;
  static const int SPINE_PROPERTY_SLIDER_MIX = 1073741824;
}

abstract class spine_rotate_mode {
  static const int SPINE_ROTATE_MODE_TANGENT = 0;
  static const int SPINE_ROTATE_MODE_CHAIN = 1;
  static const int SPINE_ROTATE_MODE_CHAIN_SCALE = 2;
}

abstract class spine_sequence_mode {
  static const int SPINE_SEQUENCE_MODE_HOLD = 0;
  static const int SPINE_SEQUENCE_MODE_ONCE = 1;
  static const int SPINE_SEQUENCE_MODE_LOOP = 2;
  static const int SPINE_SEQUENCE_MODE_PINGPONG = 3;
  static const int SPINE_SEQUENCE_MODE_ONCE_REVERSE = 4;
  static const int SPINE_SEQUENCE_MODE_LOOP_REVERSE = 5;
  static const int SPINE_SEQUENCE_MODE_PINGPONG_REVERSE = 6;
}

abstract class spine_spacing_mode {
  static const int SPINE_SPACING_MODE_LENGTH = 0;
  static const int SPINE_SPACING_MODE_FIXED = 1;
  static const int SPINE_SPACING_MODE_PERCENT = 2;
  static const int SPINE_SPACING_MODE_PROPORTIONAL = 3;
}

abstract class spine_texture_filter {
  static const int SPINE_TEXTURE_FILTER_UNKNOWN = 0;
  static const int SPINE_TEXTURE_FILTER_NEAREST = 1;
  static const int SPINE_TEXTURE_FILTER_LINEAR = 2;
  static const int SPINE_TEXTURE_FILTER_MIP_MAP = 3;
  static const int SPINE_TEXTURE_FILTER_MIP_MAP_NEAREST_NEAREST = 4;
  static const int SPINE_TEXTURE_FILTER_MIP_MAP_LINEAR_NEAREST = 5;
  static const int SPINE_TEXTURE_FILTER_MIP_MAP_NEAREST_LINEAR = 6;
  static const int SPINE_TEXTURE_FILTER_MIP_MAP_LINEAR_LINEAR = 7;
}

abstract class spine_texture_wrap {
  static const int SPINE_TEXTURE_WRAP_MIRRORED_REPEAT = 0;
  static const int SPINE_TEXTURE_WRAP_CLAMP_TO_EDGE = 1;
  static const int SPINE_TEXTURE_WRAP_REPEAT = 2;
}

final class spine_array_float_wrapper extends ffi.Opaque {}

final class spine_array_int_wrapper extends ffi.Opaque {}

final class spine_array_unsigned_short_wrapper extends ffi.Opaque {}

final class spine_array_property_id_wrapper extends ffi.Opaque {}

final class spine_array_animation_wrapper extends ffi.Opaque {}

final class spine_array_atlas_page_wrapper extends ffi.Opaque {}

final class spine_array_atlas_region_wrapper extends ffi.Opaque {}

final class spine_array_attachment_wrapper extends ffi.Opaque {}

final class spine_array_bone_wrapper extends ffi.Opaque {}

final class spine_array_bone_data_wrapper extends ffi.Opaque {}

final class spine_array_bone_pose_wrapper extends ffi.Opaque {}

final class spine_array_bounding_box_attachment_wrapper extends ffi.Opaque {}

final class spine_array_constraint_wrapper extends ffi.Opaque {}

final class spine_array_constraint_data_wrapper extends ffi.Opaque {}

final class spine_array_event_wrapper extends ffi.Opaque {}

final class spine_array_event_data_wrapper extends ffi.Opaque {}

final class spine_array_from_property_wrapper extends ffi.Opaque {}

final class spine_array_physics_constraint_wrapper extends ffi.Opaque {}

final class spine_array_polygon_wrapper extends ffi.Opaque {}

final class spine_array_skin_wrapper extends ffi.Opaque {}

final class spine_array_slot_wrapper extends ffi.Opaque {}

final class spine_array_slot_data_wrapper extends ffi.Opaque {}

final class spine_array_texture_region_wrapper extends ffi.Opaque {}

final class spine_array_timeline_wrapper extends ffi.Opaque {}

final class spine_array_to_property_wrapper extends ffi.Opaque {}

final class spine_array_track_entry_wrapper extends ffi.Opaque {}

final class spine_array_update_wrapper extends ffi.Opaque {}

typedef spine_array_float = ffi.Pointer<spine_array_float_wrapper>;
typedef spine_array_int = ffi.Pointer<spine_array_int_wrapper>;
typedef spine_array_unsigned_short = ffi.Pointer<spine_array_unsigned_short_wrapper>;
typedef spine_array_property_id = ffi.Pointer<spine_array_property_id_wrapper>;
typedef spine_array_animation = ffi.Pointer<spine_array_animation_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_animation = ffi.Pointer<spine_animation_wrapper>;
typedef spine_array_atlas_page = ffi.Pointer<spine_array_atlas_page_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_atlas_page = ffi.Pointer<spine_atlas_page_wrapper>;
typedef spine_array_atlas_region = ffi.Pointer<spine_array_atlas_region_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_atlas_region = ffi.Pointer<spine_atlas_region_wrapper>;
typedef spine_array_attachment = ffi.Pointer<spine_array_attachment_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_attachment = ffi.Pointer<spine_attachment_wrapper>;
typedef spine_array_bone = ffi.Pointer<spine_array_bone_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_bone = ffi.Pointer<spine_bone_wrapper>;
typedef spine_array_bone_data = ffi.Pointer<spine_array_bone_data_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_bone_data = ffi.Pointer<spine_bone_data_wrapper>;
typedef spine_array_bone_pose = ffi.Pointer<spine_array_bone_pose_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_bone_pose = ffi.Pointer<spine_bone_pose_wrapper>;
typedef spine_array_bounding_box_attachment = ffi.Pointer<spine_array_bounding_box_attachment_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_bounding_box_attachment = ffi.Pointer<spine_bounding_box_attachment_wrapper>;
typedef spine_array_constraint = ffi.Pointer<spine_array_constraint_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_constraint = ffi.Pointer<spine_constraint_wrapper>;
typedef spine_array_constraint_data = ffi.Pointer<spine_array_constraint_data_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_constraint_data = ffi.Pointer<spine_constraint_data_wrapper>;
typedef spine_array_event = ffi.Pointer<spine_array_event_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_event = ffi.Pointer<spine_event_wrapper>;
typedef spine_array_event_data = ffi.Pointer<spine_array_event_data_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_event_data = ffi.Pointer<spine_event_data_wrapper>;
typedef spine_array_from_property = ffi.Pointer<spine_array_from_property_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_from_property = ffi.Pointer<spine_from_property_wrapper>;
typedef spine_array_physics_constraint = ffi.Pointer<spine_array_physics_constraint_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_physics_constraint = ffi.Pointer<spine_physics_constraint_wrapper>;
typedef spine_array_polygon = ffi.Pointer<spine_array_polygon_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_polygon = ffi.Pointer<spine_polygon_wrapper>;
typedef spine_array_skin = ffi.Pointer<spine_array_skin_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_skin = ffi.Pointer<spine_skin_wrapper>;
typedef spine_array_slot = ffi.Pointer<spine_array_slot_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_slot = ffi.Pointer<spine_slot_wrapper>;
typedef spine_array_slot_data = ffi.Pointer<spine_array_slot_data_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_slot_data = ffi.Pointer<spine_slot_data_wrapper>;
typedef spine_array_texture_region = ffi.Pointer<spine_array_texture_region_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_texture_region = ffi.Pointer<spine_texture_region_wrapper>;
typedef spine_array_timeline = ffi.Pointer<spine_array_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_timeline = ffi.Pointer<spine_timeline_wrapper>;
typedef spine_array_to_property = ffi.Pointer<spine_array_to_property_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_to_property = ffi.Pointer<spine_to_property_wrapper>;
typedef spine_array_track_entry = ffi.Pointer<spine_array_track_entry_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_track_entry = ffi.Pointer<spine_track_entry_wrapper>;
typedef spine_array_update = ffi.Pointer<spine_array_update_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_update = ffi.Pointer<spine_update_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_rtti = ffi.Pointer<spine_rtti_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_skeleton = ffi.Pointer<spine_skeleton_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_bone_local = ffi.Pointer<spine_bone_local_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_atlas = ffi.Pointer<spine_atlas_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_skeleton_data = ffi.Pointer<spine_skeleton_data_wrapper>;

/// Custom types for spine-c-new (not generated)
final class spine_atlas_result_wrapper extends ffi.Opaque {}

final class spine_skeleton_data_result_wrapper extends ffi.Opaque {}

final class spine_skeleton_drawable_wrapper extends ffi.Opaque {}

final class spine_animation_state_events_wrapper extends ffi.Opaque {}

final class spine_skin_entry_wrapper extends ffi.Opaque {}

final class spine_skin_entries_wrapper extends ffi.Opaque {}

final class spine_texture_loader_wrapper extends ffi.Opaque {}

/// Custom types for spine-c-new (not generated)
typedef spine_atlas_result = ffi.Pointer<spine_atlas_result_wrapper>;

/// Texture loader callbacks
typedef spine_texture_loader_load_func = ffi.Pointer<ffi.NativeFunction<spine_texture_loader_load_funcFunction>>;
typedef spine_texture_loader_load_funcFunction = ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Char> path);
typedef spine_texture_loader_unload_func = ffi.Pointer<ffi.NativeFunction<spine_texture_loader_unload_funcFunction>>;
typedef spine_texture_loader_unload_funcFunction = ffi.Void Function(ffi.Pointer<ffi.Void> texture);
typedef Dartspine_texture_loader_unload_funcFunction = void Function(ffi.Pointer<ffi.Void> texture);

/// Custom types for spine-c-new (not generated)
typedef spine_skeleton_data_result = ffi.Pointer<spine_skeleton_data_result_wrapper>;

/// Custom types for spine-c-new (not generated)
typedef spine_skeleton_drawable = ffi.Pointer<spine_skeleton_drawable_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_render_command = ffi.Pointer<spine_render_command_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_animation_state = ffi.Pointer<spine_animation_state_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_animation_state_data = ffi.Pointer<spine_animation_state_data_wrapper>;

/// Custom types for spine-c-new (not generated)
typedef spine_animation_state_events = ffi.Pointer<spine_animation_state_events_wrapper>;

/// Custom types for spine-c-new (not generated)
typedef spine_skin_entries = ffi.Pointer<spine_skin_entries_wrapper>;

/// Custom types for spine-c-new (not generated)
typedef spine_skin_entry = ffi.Pointer<spine_skin_entry_wrapper>;

/// Event listener functions
typedef spine_animation_state_listener = ffi.Pointer<ffi.NativeFunction<spine_animation_state_listenerFunction>>;
typedef spine_animation_state_listenerFunction = ffi.Void Function(spine_animation_state state, ffi.Int32 type,
    spine_track_entry entry, spine_event event, ffi.Pointer<ffi.Void> user_data);
typedef Dartspine_animation_state_listenerFunction = void Function(
    spine_animation_state state, int type, spine_track_entry entry, spine_event event, ffi.Pointer<ffi.Void> user_data);

/// Forward declarations for all non-enum types
typedef spine_curve_timeline1 = ffi.Pointer<spine_curve_timeline1_wrapper>;
typedef spine_alpha_timeline = ffi.Pointer<spine_alpha_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_curve_timeline = ffi.Pointer<spine_curve_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_slot_timeline = ffi.Pointer<spine_slot_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_attachment_loader = ffi.Pointer<spine_attachment_loader_wrapper>;
typedef spine_atlas_attachment_loader = ffi.Pointer<spine_atlas_attachment_loader_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_attachment_timeline = ffi.Pointer<spine_attachment_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_posed = ffi.Pointer<spine_posed_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_posed_active = ffi.Pointer<spine_posed_active_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_posed_data = ffi.Pointer<spine_posed_data_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_bone_timeline1 = ffi.Pointer<spine_bone_timeline1_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_bone_timeline = ffi.Pointer<spine_bone_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_bone_timeline2 = ffi.Pointer<spine_bone_timeline2_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_vertex_attachment = ffi.Pointer<spine_vertex_attachment_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_clipping_attachment = ffi.Pointer<spine_clipping_attachment_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_constraint_timeline1 = ffi.Pointer<spine_constraint_timeline1_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_constraint_timeline = ffi.Pointer<spine_constraint_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_slot_curve_timeline = ffi.Pointer<spine_slot_curve_timeline_wrapper>;
typedef spine_deform_timeline = ffi.Pointer<spine_deform_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_draw_order_timeline = ffi.Pointer<spine_draw_order_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_event_timeline = ffi.Pointer<spine_event_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_from_rotate = ffi.Pointer<spine_from_rotate_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_from_scale_x = ffi.Pointer<spine_from_scale_x_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_from_scale_y = ffi.Pointer<spine_from_scale_y_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_from_shear_y = ffi.Pointer<spine_from_shear_y_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_from_x = ffi.Pointer<spine_from_x_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_from_y = ffi.Pointer<spine_from_y_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_ik_constraint_base = ffi.Pointer<spine_ik_constraint_base_wrapper>;
typedef spine_ik_constraint = ffi.Pointer<spine_ik_constraint_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_ik_constraint_data = ffi.Pointer<spine_ik_constraint_data_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_ik_constraint_timeline = ffi.Pointer<spine_ik_constraint_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_inherit_timeline = ffi.Pointer<spine_inherit_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_mesh_attachment = ffi.Pointer<spine_mesh_attachment_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_path_attachment = ffi.Pointer<spine_path_attachment_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_path_constraint_base = ffi.Pointer<spine_path_constraint_base_wrapper>;
typedef spine_path_constraint = ffi.Pointer<spine_path_constraint_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_path_constraint_data = ffi.Pointer<spine_path_constraint_data_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_path_constraint_mix_timeline = ffi.Pointer<spine_path_constraint_mix_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_path_constraint_position_timeline = ffi.Pointer<spine_path_constraint_position_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_path_constraint_spacing_timeline = ffi.Pointer<spine_path_constraint_spacing_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_physics_constraint_base = ffi.Pointer<spine_physics_constraint_base_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_physics_constraint_timeline = ffi.Pointer<spine_physics_constraint_timeline_wrapper>;
typedef spine_physics_constraint_damping_timeline = ffi.Pointer<spine_physics_constraint_damping_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_physics_constraint_data = ffi.Pointer<spine_physics_constraint_data_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_physics_constraint_gravity_timeline = ffi.Pointer<spine_physics_constraint_gravity_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_physics_constraint_inertia_timeline = ffi.Pointer<spine_physics_constraint_inertia_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_physics_constraint_mass_timeline = ffi.Pointer<spine_physics_constraint_mass_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_physics_constraint_mix_timeline = ffi.Pointer<spine_physics_constraint_mix_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_physics_constraint_reset_timeline = ffi.Pointer<spine_physics_constraint_reset_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_physics_constraint_strength_timeline = ffi.Pointer<spine_physics_constraint_strength_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_physics_constraint_wind_timeline = ffi.Pointer<spine_physics_constraint_wind_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_point_attachment = ffi.Pointer<spine_point_attachment_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_region_attachment = ffi.Pointer<spine_region_attachment_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_rgb2_timeline = ffi.Pointer<spine_rgb2_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_rgba2_timeline = ffi.Pointer<spine_rgba2_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_rgba_timeline = ffi.Pointer<spine_rgba_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_rgb_timeline = ffi.Pointer<spine_rgb_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_rotate_timeline = ffi.Pointer<spine_rotate_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_scale_timeline = ffi.Pointer<spine_scale_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_scale_x_timeline = ffi.Pointer<spine_scale_x_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_scale_y_timeline = ffi.Pointer<spine_scale_y_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_sequence_timeline = ffi.Pointer<spine_sequence_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_shear_timeline = ffi.Pointer<spine_shear_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_shear_x_timeline = ffi.Pointer<spine_shear_x_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_shear_y_timeline = ffi.Pointer<spine_shear_y_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_slider_base = ffi.Pointer<spine_slider_base_wrapper>;
typedef spine_slider = ffi.Pointer<spine_slider_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_slider_data = ffi.Pointer<spine_slider_data_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_slider_mix_timeline = ffi.Pointer<spine_slider_mix_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_slider_timeline = ffi.Pointer<spine_slider_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_to_rotate = ffi.Pointer<spine_to_rotate_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_to_scale_x = ffi.Pointer<spine_to_scale_x_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_to_scale_y = ffi.Pointer<spine_to_scale_y_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_to_shear_y = ffi.Pointer<spine_to_shear_y_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_to_x = ffi.Pointer<spine_to_x_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_to_y = ffi.Pointer<spine_to_y_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_transform_constraint_base = ffi.Pointer<spine_transform_constraint_base_wrapper>;
typedef spine_transform_constraint = ffi.Pointer<spine_transform_constraint_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_transform_constraint_data = ffi.Pointer<spine_transform_constraint_data_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_transform_constraint_timeline = ffi.Pointer<spine_transform_constraint_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_translate_timeline = ffi.Pointer<spine_translate_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_translate_x_timeline = ffi.Pointer<spine_translate_x_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_translate_y_timeline = ffi.Pointer<spine_translate_y_timeline_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_sequence = ffi.Pointer<spine_sequence_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_color = ffi.Pointer<spine_color_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_event_queue_entry = ffi.Pointer<spine_event_queue_entry_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_ik_constraint_pose = ffi.Pointer<spine_ik_constraint_pose_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_linked_mesh = ffi.Pointer<spine_linked_mesh_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_path_constraint_pose = ffi.Pointer<spine_path_constraint_pose_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_physics_constraint_pose = ffi.Pointer<spine_physics_constraint_pose_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_slot_pose = ffi.Pointer<spine_slot_pose_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_skeleton_clipping = ffi.Pointer<spine_skeleton_clipping_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_skeleton_binary = ffi.Pointer<spine_skeleton_binary_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_skeleton_bounds = ffi.Pointer<spine_skeleton_bounds_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_skeleton_json = ffi.Pointer<spine_skeleton_json_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_skeleton_renderer = ffi.Pointer<spine_skeleton_renderer_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_slider_pose = ffi.Pointer<spine_slider_pose_wrapper>;

/// Forward declarations for all non-enum types
typedef spine_transform_constraint_pose = ffi.Pointer<spine_transform_constraint_pose_wrapper>;