// 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 'ffi_proxy.dart' as ffi;

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

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

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

  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(int enable) {
    return _spine_enable_debug_extension(enable);
  }

  late final _spine_enable_debug_extensionPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bool)>>(
    'spine_enable_debug_extension',
  );
  late final _spine_enable_debug_extension = _spine_enable_debug_extensionPtr.asFunction<void Function(int)>();

  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()>();

  double spine_color_get_r(spine_color color) {
    return _spine_color_get_r(color);
  }

  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)>();

  double spine_color_get_g(spine_color color) {
    return _spine_color_get_g(color);
  }

  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)>();

  double spine_color_get_b(spine_color color) {
    return _spine_color_get_b(color);
  }

  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)>();

  double spine_color_get_a(spine_color color) {
    return _spine_color_get_a(color);
  }

  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)>();

  double spine_bounds_get_x(spine_bounds bounds) {
    return _spine_bounds_get_x(bounds);
  }

  late final _spine_bounds_get_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bounds)>>(
    'spine_bounds_get_x',
  );
  late final _spine_bounds_get_x = _spine_bounds_get_xPtr.asFunction<double Function(spine_bounds)>();

  double spine_bounds_get_y(spine_bounds bounds) {
    return _spine_bounds_get_y(bounds);
  }

  late final _spine_bounds_get_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bounds)>>(
    'spine_bounds_get_y',
  );
  late final _spine_bounds_get_y = _spine_bounds_get_yPtr.asFunction<double Function(spine_bounds)>();

  double spine_bounds_get_width(spine_bounds bounds) {
    return _spine_bounds_get_width(bounds);
  }

  late final _spine_bounds_get_widthPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bounds)>>(
    'spine_bounds_get_width',
  );
  late final _spine_bounds_get_width = _spine_bounds_get_widthPtr.asFunction<double Function(spine_bounds)>();

  double spine_bounds_get_height(spine_bounds bounds) {
    return _spine_bounds_get_height(bounds);
  }

  late final _spine_bounds_get_heightPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bounds)>>(
    'spine_bounds_get_height',
  );
  late final _spine_bounds_get_height = _spine_bounds_get_heightPtr.asFunction<double Function(spine_bounds)>();

  double spine_vector_get_x(spine_vector vector) {
    return _spine_vector_get_x(vector);
  }

  late final _spine_vector_get_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_vector)>>(
    'spine_vector_get_x',
  );
  late final _spine_vector_get_x = _spine_vector_get_xPtr.asFunction<double Function(spine_vector)>();

  double spine_vector_get_y(spine_vector vector) {
    return _spine_vector_get_y(vector);
  }

  late final _spine_vector_get_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_vector)>>(
    'spine_vector_get_y',
  );
  late final _spine_vector_get_y = _spine_vector_get_yPtr.asFunction<double Function(spine_vector)>();

  spine_atlas spine_atlas_load(ffi.Pointer<utf8> atlasData) {
    return _spine_atlas_load(atlasData);
  }

  late final _spine_atlas_loadPtr = _lookup<ffi.NativeFunction<spine_atlas Function(ffi.Pointer<utf8>)>>(
    'spine_atlas_load',
  );
  late final _spine_atlas_load = _spine_atlas_loadPtr.asFunction<spine_atlas Function(ffi.Pointer<utf8>)>();

  int spine_atlas_get_num_image_paths(spine_atlas atlas) {
    return _spine_atlas_get_num_image_paths(atlas);
  }

  late final _spine_atlas_get_num_image_pathsPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_atlas)>>(
    'spine_atlas_get_num_image_paths',
  );
  late final _spine_atlas_get_num_image_paths = _spine_atlas_get_num_image_pathsPtr
      .asFunction<int Function(spine_atlas)>();

  ffi.Pointer<utf8> spine_atlas_get_image_path(spine_atlas atlas, int index) {
    return _spine_atlas_get_image_path(atlas, index);
  }

  late final _spine_atlas_get_image_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_atlas, ffi.Int32)>>('spine_atlas_get_image_path');
  late final _spine_atlas_get_image_path = _spine_atlas_get_image_pathPtr
      .asFunction<ffi.Pointer<utf8> Function(spine_atlas, int)>();

  ffi.Pointer<utf8> spine_atlas_get_error(spine_atlas atlas) {
    return _spine_atlas_get_error(atlas);
  }

  late final _spine_atlas_get_errorPtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_atlas)>>(
    'spine_atlas_get_error',
  );
  late final _spine_atlas_get_error = _spine_atlas_get_errorPtr.asFunction<ffi.Pointer<utf8> Function(spine_atlas)>();

  void spine_atlas_dispose(spine_atlas atlas) {
    return _spine_atlas_dispose(atlas);
  }

  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)>();

  spine_skeleton_data_result spine_skeleton_data_load_json(spine_atlas atlas, ffi.Pointer<utf8> skeletonData) {
    return _spine_skeleton_data_load_json(atlas, skeletonData);
  }

  late final _spine_skeleton_data_load_jsonPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_data_result Function(spine_atlas, ffi.Pointer<utf8>)>>(
        '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<utf8>)>();

  spine_skeleton_data_result spine_skeleton_data_load_binary(
    spine_atlas atlas,
    ffi.Pointer<ffi.Uint8> skeletonData,
    int length,
  ) {
    return _spine_skeleton_data_load_binary(atlas, skeletonData, length);
  }

  late final _spine_skeleton_data_load_binaryPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_data_result Function(spine_atlas, ffi.Pointer<ffi.Uint8>, ffi.Int32)>>(
        '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<utf8> 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<utf8> 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<utf8> 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)>();

  spine_bone_data spine_skeleton_data_find_bone(spine_skeleton_data data, ffi.Pointer<utf8> name) {
    return _spine_skeleton_data_find_bone(data, name);
  }

  late final _spine_skeleton_data_find_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
        '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<utf8>)>();

  spine_slot_data spine_skeleton_data_find_slot(spine_skeleton_data data, ffi.Pointer<utf8> name) {
    return _spine_skeleton_data_find_slot(data, name);
  }

  late final _spine_skeleton_data_find_slotPtr =
      _lookup<ffi.NativeFunction<spine_slot_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
        '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<utf8>)>();

  spine_skin spine_skeleton_data_find_skin(spine_skeleton_data data, ffi.Pointer<utf8> name) {
    return _spine_skeleton_data_find_skin(data, name);
  }

  late final _spine_skeleton_data_find_skinPtr =
      _lookup<ffi.NativeFunction<spine_skin Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
        '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<utf8>)>();

  spine_event_data spine_skeleton_data_find_event(spine_skeleton_data data, ffi.Pointer<utf8> name) {
    return _spine_skeleton_data_find_event(data, name);
  }

  late final _spine_skeleton_data_find_eventPtr =
      _lookup<ffi.NativeFunction<spine_event_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
        '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<utf8>)>();

  spine_animation spine_skeleton_data_find_animation(spine_skeleton_data data, ffi.Pointer<utf8> name) {
    return _spine_skeleton_data_find_animation(data, name);
  }

  late final _spine_skeleton_data_find_animationPtr =
      _lookup<ffi.NativeFunction<spine_animation Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
        '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<utf8>)>();

  spine_ik_constraint_data spine_skeleton_data_find_ik_constraint(spine_skeleton_data data, ffi.Pointer<utf8> name) {
    return _spine_skeleton_data_find_ik_constraint(data, name);
  }

  late final _spine_skeleton_data_find_ik_constraintPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
        'spine_skeleton_data_find_ik_constraint',
      );
  late final _spine_skeleton_data_find_ik_constraint = _spine_skeleton_data_find_ik_constraintPtr
      .asFunction<spine_ik_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>();

  spine_transform_constraint_data spine_skeleton_data_find_transform_constraint(
    spine_skeleton_data data,
    ffi.Pointer<utf8> name,
  ) {
    return _spine_skeleton_data_find_transform_constraint(data, name);
  }

  late final _spine_skeleton_data_find_transform_constraintPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
        'spine_skeleton_data_find_transform_constraint',
      );
  late final _spine_skeleton_data_find_transform_constraint = _spine_skeleton_data_find_transform_constraintPtr
      .asFunction<spine_transform_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>();

  spine_path_constraint_data spine_skeleton_data_find_path_constraint(
    spine_skeleton_data data,
    ffi.Pointer<utf8> name,
  ) {
    return _spine_skeleton_data_find_path_constraint(data, name);
  }

  late final _spine_skeleton_data_find_path_constraintPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
        'spine_skeleton_data_find_path_constraint',
      );
  late final _spine_skeleton_data_find_path_constraint = _spine_skeleton_data_find_path_constraintPtr
      .asFunction<spine_path_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>();

  spine_physics_constraint_data spine_skeleton_data_find_physics_constraint(
    spine_skeleton_data data,
    ffi.Pointer<utf8> name,
  ) {
    return _spine_skeleton_data_find_physics_constraint(data, name);
  }

  late final _spine_skeleton_data_find_physics_constraintPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
        'spine_skeleton_data_find_physics_constraint',
      );
  late final _spine_skeleton_data_find_physics_constraint = _spine_skeleton_data_find_physics_constraintPtr
      .asFunction<spine_physics_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>();

  ffi.Pointer<utf8> spine_skeleton_data_get_name(spine_skeleton_data data) {
    return _spine_skeleton_data_get_name(data);
  }

  late final _spine_skeleton_data_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>>('spine_skeleton_data_get_name');
  late final _spine_skeleton_data_get_name = _spine_skeleton_data_get_namePtr
      .asFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>();

  /// OMITTED setName()
  int spine_skeleton_data_get_num_bones(spine_skeleton_data data) {
    return _spine_skeleton_data_get_num_bones(data);
  }

  late final _spine_skeleton_data_get_num_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>('spine_skeleton_data_get_num_bones');
  late final _spine_skeleton_data_get_num_bones = _spine_skeleton_data_get_num_bonesPtr
      .asFunction<int Function(spine_skeleton_data)>();

  ffi.Pointer<spine_bone_data> spine_skeleton_data_get_bones(spine_skeleton_data data) {
    return _spine_skeleton_data_get_bones(data);
  }

  late final _spine_skeleton_data_get_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_bone_data> Function(spine_skeleton_data)>>(
        'spine_skeleton_data_get_bones',
      );
  late final _spine_skeleton_data_get_bones = _spine_skeleton_data_get_bonesPtr
      .asFunction<ffi.Pointer<spine_bone_data> Function(spine_skeleton_data)>();

  int spine_skeleton_data_get_num_slots(spine_skeleton_data data) {
    return _spine_skeleton_data_get_num_slots(data);
  }

  late final _spine_skeleton_data_get_num_slotsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>('spine_skeleton_data_get_num_slots');
  late final _spine_skeleton_data_get_num_slots = _spine_skeleton_data_get_num_slotsPtr
      .asFunction<int Function(spine_skeleton_data)>();

  ffi.Pointer<spine_slot_data> spine_skeleton_data_get_slots(spine_skeleton_data data) {
    return _spine_skeleton_data_get_slots(data);
  }

  late final _spine_skeleton_data_get_slotsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_slot_data> Function(spine_skeleton_data)>>(
        'spine_skeleton_data_get_slots',
      );
  late final _spine_skeleton_data_get_slots = _spine_skeleton_data_get_slotsPtr
      .asFunction<ffi.Pointer<spine_slot_data> Function(spine_skeleton_data)>();

  int spine_skeleton_data_get_num_skins(spine_skeleton_data data) {
    return _spine_skeleton_data_get_num_skins(data);
  }

  late final _spine_skeleton_data_get_num_skinsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>('spine_skeleton_data_get_num_skins');
  late final _spine_skeleton_data_get_num_skins = _spine_skeleton_data_get_num_skinsPtr
      .asFunction<int Function(spine_skeleton_data)>();

  ffi.Pointer<spine_skin> spine_skeleton_data_get_skins(spine_skeleton_data data) {
    return _spine_skeleton_data_get_skins(data);
  }

  late final _spine_skeleton_data_get_skinsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_skin> Function(spine_skeleton_data)>>(
        'spine_skeleton_data_get_skins',
      );
  late final _spine_skeleton_data_get_skins = _spine_skeleton_data_get_skinsPtr
      .asFunction<ffi.Pointer<spine_skin> Function(spine_skeleton_data)>();

  spine_skin spine_skeleton_data_get_default_skin(spine_skeleton_data data) {
    return _spine_skeleton_data_get_default_skin(data);
  }

  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 data, spine_skin skin) {
    return _spine_skeleton_data_set_default_skin(data, skin);
  }

  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)>();

  int spine_skeleton_data_get_num_events(spine_skeleton_data data) {
    return _spine_skeleton_data_get_num_events(data);
  }

  late final _spine_skeleton_data_get_num_eventsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>('spine_skeleton_data_get_num_events');
  late final _spine_skeleton_data_get_num_events = _spine_skeleton_data_get_num_eventsPtr
      .asFunction<int Function(spine_skeleton_data)>();

  ffi.Pointer<spine_event_data> spine_skeleton_data_get_events(spine_skeleton_data data) {
    return _spine_skeleton_data_get_events(data);
  }

  late final _spine_skeleton_data_get_eventsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_event_data> Function(spine_skeleton_data)>>(
        'spine_skeleton_data_get_events',
      );
  late final _spine_skeleton_data_get_events = _spine_skeleton_data_get_eventsPtr
      .asFunction<ffi.Pointer<spine_event_data> Function(spine_skeleton_data)>();

  int spine_skeleton_data_get_num_animations(spine_skeleton_data data) {
    return _spine_skeleton_data_get_num_animations(data);
  }

  late final _spine_skeleton_data_get_num_animationsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>('spine_skeleton_data_get_num_animations');
  late final _spine_skeleton_data_get_num_animations = _spine_skeleton_data_get_num_animationsPtr
      .asFunction<int Function(spine_skeleton_data)>();

  ffi.Pointer<spine_animation> spine_skeleton_data_get_animations(spine_skeleton_data data) {
    return _spine_skeleton_data_get_animations(data);
  }

  late final _spine_skeleton_data_get_animationsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_animation> Function(spine_skeleton_data)>>(
        'spine_skeleton_data_get_animations',
      );
  late final _spine_skeleton_data_get_animations = _spine_skeleton_data_get_animationsPtr
      .asFunction<ffi.Pointer<spine_animation> Function(spine_skeleton_data)>();

  int spine_skeleton_data_get_num_ik_constraints(spine_skeleton_data data) {
    return _spine_skeleton_data_get_num_ik_constraints(data);
  }

  late final _spine_skeleton_data_get_num_ik_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>(
        'spine_skeleton_data_get_num_ik_constraints',
      );
  late final _spine_skeleton_data_get_num_ik_constraints = _spine_skeleton_data_get_num_ik_constraintsPtr
      .asFunction<int Function(spine_skeleton_data)>();

  ffi.Pointer<spine_ik_constraint_data> spine_skeleton_data_get_ik_constraints(spine_skeleton_data data) {
    return _spine_skeleton_data_get_ik_constraints(data);
  }

  late final _spine_skeleton_data_get_ik_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_ik_constraint_data> Function(spine_skeleton_data)>>(
        'spine_skeleton_data_get_ik_constraints',
      );
  late final _spine_skeleton_data_get_ik_constraints = _spine_skeleton_data_get_ik_constraintsPtr
      .asFunction<ffi.Pointer<spine_ik_constraint_data> Function(spine_skeleton_data)>();

  int spine_skeleton_data_get_num_transform_constraints(spine_skeleton_data data) {
    return _spine_skeleton_data_get_num_transform_constraints(data);
  }

  late final _spine_skeleton_data_get_num_transform_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>(
        'spine_skeleton_data_get_num_transform_constraints',
      );
  late final _spine_skeleton_data_get_num_transform_constraints = _spine_skeleton_data_get_num_transform_constraintsPtr
      .asFunction<int Function(spine_skeleton_data)>();

  ffi.Pointer<spine_transform_constraint_data> spine_skeleton_data_get_transform_constraints(spine_skeleton_data data) {
    return _spine_skeleton_data_get_transform_constraints(data);
  }

  late final _spine_skeleton_data_get_transform_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_transform_constraint_data> Function(spine_skeleton_data)>>(
        'spine_skeleton_data_get_transform_constraints',
      );
  late final _spine_skeleton_data_get_transform_constraints = _spine_skeleton_data_get_transform_constraintsPtr
      .asFunction<ffi.Pointer<spine_transform_constraint_data> Function(spine_skeleton_data)>();

  int spine_skeleton_data_get_num_path_constraints(spine_skeleton_data data) {
    return _spine_skeleton_data_get_num_path_constraints(data);
  }

  late final _spine_skeleton_data_get_num_path_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>(
        'spine_skeleton_data_get_num_path_constraints',
      );
  late final _spine_skeleton_data_get_num_path_constraints = _spine_skeleton_data_get_num_path_constraintsPtr
      .asFunction<int Function(spine_skeleton_data)>();

  ffi.Pointer<spine_path_constraint_data> spine_skeleton_data_get_path_constraints(spine_skeleton_data data) {
    return _spine_skeleton_data_get_path_constraints(data);
  }

  late final _spine_skeleton_data_get_path_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_path_constraint_data> Function(spine_skeleton_data)>>(
        'spine_skeleton_data_get_path_constraints',
      );
  late final _spine_skeleton_data_get_path_constraints = _spine_skeleton_data_get_path_constraintsPtr
      .asFunction<ffi.Pointer<spine_path_constraint_data> Function(spine_skeleton_data)>();

  int spine_skeleton_data_get_num_physics_constraints(spine_skeleton_data data) {
    return _spine_skeleton_data_get_num_physics_constraints(data);
  }

  late final _spine_skeleton_data_get_num_physics_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>(
        'spine_skeleton_data_get_num_physics_constraints',
      );
  late final _spine_skeleton_data_get_num_physics_constraints = _spine_skeleton_data_get_num_physics_constraintsPtr
      .asFunction<int Function(spine_skeleton_data)>();

  ffi.Pointer<spine_physics_constraint_data> spine_skeleton_data_get_physics_constraints(spine_skeleton_data data) {
    return _spine_skeleton_data_get_physics_constraints(data);
  }

  late final _spine_skeleton_data_get_physics_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_physics_constraint_data> Function(spine_skeleton_data)>>(
        'spine_skeleton_data_get_physics_constraints',
      );
  late final _spine_skeleton_data_get_physics_constraints = _spine_skeleton_data_get_physics_constraintsPtr
      .asFunction<ffi.Pointer<spine_physics_constraint_data> Function(spine_skeleton_data)>();

  double spine_skeleton_data_get_x(spine_skeleton_data data) {
    return _spine_skeleton_data_get_x(data);
  }

  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 data, double x) {
    return _spine_skeleton_data_set_x(data, x);
  }

  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)>();

  double spine_skeleton_data_get_y(spine_skeleton_data data) {
    return _spine_skeleton_data_get_y(data);
  }

  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 data, double y) {
    return _spine_skeleton_data_set_y(data, y);
  }

  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)>();

  double spine_skeleton_data_get_width(spine_skeleton_data data) {
    return _spine_skeleton_data_get_width(data);
  }

  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 data, double width) {
    return _spine_skeleton_data_set_width(data, width);
  }

  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)>();

  double spine_skeleton_data_get_height(spine_skeleton_data data) {
    return _spine_skeleton_data_get_height(data);
  }

  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 data, double height) {
    return _spine_skeleton_data_set_height(data, height);
  }

  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)>();

  ffi.Pointer<utf8> spine_skeleton_data_get_version(spine_skeleton_data data) {
    return _spine_skeleton_data_get_version(data);
  }

  late final _spine_skeleton_data_get_versionPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>>('spine_skeleton_data_get_version');
  late final _spine_skeleton_data_get_version = _spine_skeleton_data_get_versionPtr
      .asFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>();

  /// OMITTED setVersion()
  ffi.Pointer<utf8> spine_skeleton_data_get_hash(spine_skeleton_data data) {
    return _spine_skeleton_data_get_hash(data);
  }

  late final _spine_skeleton_data_get_hashPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>>('spine_skeleton_data_get_hash');
  late final _spine_skeleton_data_get_hash = _spine_skeleton_data_get_hashPtr
      .asFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>();

  /// OMITTED setHash()
  ffi.Pointer<utf8> spine_skeleton_data_get_images_path(spine_skeleton_data data) {
    return _spine_skeleton_data_get_images_path(data);
  }

  late final _spine_skeleton_data_get_images_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<utf8> 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<utf8> Function(spine_skeleton_data)>();

  /// OMITTED setImagesPath()
  ffi.Pointer<utf8> spine_skeleton_data_get_audio_path(spine_skeleton_data data) {
    return _spine_skeleton_data_get_audio_path(data);
  }

  late final _spine_skeleton_data_get_audio_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<utf8> 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<utf8> Function(spine_skeleton_data)>();

  /// OMITTED setAudioPath()
  double spine_skeleton_data_get_fps(spine_skeleton_data data) {
    return _spine_skeleton_data_get_fps(data);
  }

  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)>();

  /// OMITTED setFps()
  double spine_skeleton_data_get_reference_scale(spine_skeleton_data data) {
    return _spine_skeleton_data_get_reference_scale(data);
  }

  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_dispose(spine_skeleton_data data) {
    return _spine_skeleton_data_dispose(data);
  }

  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_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)>();

  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)>();

  ffi.Pointer<ffi.Float> spine_render_command_get_positions(spine_render_command command) {
    return _spine_render_command_get_positions(command);
  }

  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 command) {
    return _spine_render_command_get_uvs(command);
  }

  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.Int32> spine_render_command_get_colors(spine_render_command command) {
    return _spine_render_command_get_colors(command);
  }

  late final _spine_render_command_get_colorsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Int32> 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.Int32> Function(spine_render_command)>();

  int spine_render_command_get_num_vertices(spine_render_command command) {
    return _spine_render_command_get_num_vertices(command);
  }

  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 command) {
    return _spine_render_command_get_indices(command);
  }

  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 command) {
    return _spine_render_command_get_num_indices(command);
  }

  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_atlas_page(spine_render_command command) {
    return _spine_render_command_get_atlas_page(command);
  }

  late final _spine_render_command_get_atlas_pagePtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_render_command)>>('spine_render_command_get_atlas_page');
  late final _spine_render_command_get_atlas_page = _spine_render_command_get_atlas_pagePtr
      .asFunction<int Function(spine_render_command)>();

  int spine_render_command_get_blend_mode(spine_render_command command) {
    return _spine_render_command_get_blend_mode(command);
  }

  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)>();

  spine_render_command spine_render_command_get_next(spine_render_command command) {
    return _spine_render_command_get_next(command);
  }

  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)>();

  ffi.Pointer<utf8> spine_animation_get_name(spine_animation animation) {
    return _spine_animation_get_name(animation);
  }

  late final _spine_animation_get_namePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_animation)>>(
    'spine_animation_get_name',
  );
  late final _spine_animation_get_name = _spine_animation_get_namePtr
      .asFunction<ffi.Pointer<utf8> Function(spine_animation)>();

  /// OMITTED getTimelines()
  /// OMITTED hasTimeline()
  double spine_animation_get_duration(spine_animation animation) {
    return _spine_animation_get_duration(animation);
  }

  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)>();

  /// OMITTED setDuration()
  spine_skeleton_data spine_animation_state_data_get_skeleton_data(spine_animation_state_data stateData) {
    return _spine_animation_state_data_get_skeleton_data(stateData);
  }

  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)>();

  double spine_animation_state_data_get_default_mix(spine_animation_state_data stateData) {
    return _spine_animation_state_data_get_default_mix(stateData);
  }

  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 stateData, double defaultMix) {
    return _spine_animation_state_data_set_default_mix(stateData, defaultMix);
  }

  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)>();

  void spine_animation_state_data_set_mix(
    spine_animation_state_data stateData,
    spine_animation from,
    spine_animation to,
    double duration,
  ) {
    return _spine_animation_state_data_set_mix(stateData, from, to, duration);
  }

  late final _spine_animation_state_data_set_mixPtr =
      _lookup<
        ffi.NativeFunction<ffi.Void Function(spine_animation_state_data, spine_animation, spine_animation, ffi.Float)>
      >('spine_animation_state_data_set_mix');
  late final _spine_animation_state_data_set_mix = _spine_animation_state_data_set_mixPtr
      .asFunction<void Function(spine_animation_state_data, spine_animation, spine_animation, double)>();

  double spine_animation_state_data_get_mix(
    spine_animation_state_data stateData,
    spine_animation from,
    spine_animation to,
  ) {
    return _spine_animation_state_data_get_mix(stateData, 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)>();

  void spine_animation_state_data_set_mix_by_name(
    spine_animation_state_data stateData,
    ffi.Pointer<utf8> fromName,
    ffi.Pointer<utf8> toName,
    double duration,
  ) {
    return _spine_animation_state_data_set_mix_by_name(stateData, fromName, toName, duration);
  }

  late final _spine_animation_state_data_set_mix_by_namePtr =
      _lookup<
        ffi.NativeFunction<
          ffi.Void Function(spine_animation_state_data, ffi.Pointer<utf8>, ffi.Pointer<utf8>, ffi.Float)
        >
      >('spine_animation_state_data_set_mix_by_name');
  late final _spine_animation_state_data_set_mix_by_name = _spine_animation_state_data_set_mix_by_namePtr
      .asFunction<void Function(spine_animation_state_data, ffi.Pointer<utf8>, ffi.Pointer<utf8>, double)>();

  double spine_animation_state_data_get_mix_by_name(
    spine_animation_state_data stateData,
    ffi.Pointer<utf8> fromName,
    ffi.Pointer<utf8> toName,
  ) {
    return _spine_animation_state_data_get_mix_by_name(stateData, fromName, toName);
  }

  late final _spine_animation_state_data_get_mix_by_namePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_animation_state_data, ffi.Pointer<utf8>, ffi.Pointer<utf8>)>>(
        'spine_animation_state_data_get_mix_by_name',
      );
  late final _spine_animation_state_data_get_mix_by_name = _spine_animation_state_data_get_mix_by_namePtr
      .asFunction<double Function(spine_animation_state_data, ffi.Pointer<utf8>, ffi.Pointer<utf8>)>();

  void spine_animation_state_data_clear(spine_animation_state_data stateData) {
    return _spine_animation_state_data_clear(stateData);
  }

  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)>();

  void spine_animation_state_update(spine_animation_state state, double delta) {
    return _spine_animation_state_update(state, 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)>();

  void spine_animation_state_apply(spine_animation_state state, spine_skeleton skeleton) {
    return _spine_animation_state_apply(state, skeleton);
  }

  late final _spine_animation_state_applyPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state, spine_skeleton)>>(
        'spine_animation_state_apply',
      );
  late final _spine_animation_state_apply = _spine_animation_state_applyPtr
      .asFunction<void Function(spine_animation_state, spine_skeleton)>();

  void spine_animation_state_clear_tracks(spine_animation_state state) {
    return _spine_animation_state_clear_tracks(state);
  }

  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)>();

  void spine_animation_state_clear_track(spine_animation_state state, int trackIndex) {
    return _spine_animation_state_clear_track(state, trackIndex);
  }

  late final _spine_animation_state_clear_trackPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state, ffi.Int32)>>(
        'spine_animation_state_clear_track',
      );
  late final _spine_animation_state_clear_track = _spine_animation_state_clear_trackPtr
      .asFunction<void Function(spine_animation_state, int)>();

  int spine_animation_state_get_num_tracks(spine_animation_state state) {
    return _spine_animation_state_get_num_tracks(state);
  }

  late final _spine_animation_state_get_num_tracksPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_animation_state)>>('spine_animation_state_get_num_tracks');
  late final _spine_animation_state_get_num_tracks = _spine_animation_state_get_num_tracksPtr
      .asFunction<int Function(spine_animation_state)>();

  spine_track_entry spine_animation_state_set_animation_by_name(
    spine_animation_state state,
    int trackIndex,
    ffi.Pointer<utf8> animationName,
    int loop,
  ) {
    return _spine_animation_state_set_animation_by_name(state, trackIndex, animationName, loop);
  }

  late final _spine_animation_state_set_animation_by_namePtr =
      _lookup<
        ffi.NativeFunction<spine_track_entry Function(spine_animation_state, ffi.Int32, ffi.Pointer<utf8>, spine_bool)>
      >('spine_animation_state_set_animation_by_name');
  late final _spine_animation_state_set_animation_by_name = _spine_animation_state_set_animation_by_namePtr
      .asFunction<spine_track_entry Function(spine_animation_state, int, ffi.Pointer<utf8>, int)>();

  spine_track_entry spine_animation_state_set_animation(
    spine_animation_state state,
    int trackIndex,
    spine_animation animation,
    int loop,
  ) {
    return _spine_animation_state_set_animation(state, trackIndex, animation, loop);
  }

  late final _spine_animation_state_set_animationPtr =
      _lookup<
        ffi.NativeFunction<spine_track_entry Function(spine_animation_state, ffi.Int32, spine_animation, spine_bool)>
      >('spine_animation_state_set_animation');
  late final _spine_animation_state_set_animation = _spine_animation_state_set_animationPtr
      .asFunction<spine_track_entry Function(spine_animation_state, int, spine_animation, int)>();

  spine_track_entry spine_animation_state_add_animation_by_name(
    spine_animation_state state,
    int trackIndex,
    ffi.Pointer<utf8> animationName,
    int loop,
    double delay,
  ) {
    return _spine_animation_state_add_animation_by_name(state, trackIndex, animationName, loop, delay);
  }

  late final _spine_animation_state_add_animation_by_namePtr =
      _lookup<
        ffi.NativeFunction<
          spine_track_entry Function(spine_animation_state, ffi.Int32, ffi.Pointer<utf8>, spine_bool, ffi.Float)
        >
      >('spine_animation_state_add_animation_by_name');
  late final _spine_animation_state_add_animation_by_name = _spine_animation_state_add_animation_by_namePtr
      .asFunction<spine_track_entry Function(spine_animation_state, int, ffi.Pointer<utf8>, int, double)>();

  spine_track_entry spine_animation_state_add_animation(
    spine_animation_state state,
    int trackIndex,
    spine_animation animation,
    int loop,
    double delay,
  ) {
    return _spine_animation_state_add_animation(state, trackIndex, animation, loop, delay);
  }

  late final _spine_animation_state_add_animationPtr =
      _lookup<
        ffi.NativeFunction<
          spine_track_entry Function(spine_animation_state, ffi.Int32, spine_animation, spine_bool, ffi.Float)
        >
      >('spine_animation_state_add_animation');
  late final _spine_animation_state_add_animation = _spine_animation_state_add_animationPtr
      .asFunction<spine_track_entry Function(spine_animation_state, int, spine_animation, int, double)>();

  spine_track_entry spine_animation_state_set_empty_animation(
    spine_animation_state state,
    int trackIndex,
    double mixDuration,
  ) {
    return _spine_animation_state_set_empty_animation(state, trackIndex, mixDuration);
  }

  late final _spine_animation_state_set_empty_animationPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function(spine_animation_state, ffi.Int32, 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)>();

  spine_track_entry spine_animation_state_add_empty_animation(
    spine_animation_state state,
    int trackIndex,
    double mixDuration,
    double delay,
  ) {
    return _spine_animation_state_add_empty_animation(state, trackIndex, mixDuration, delay);
  }

  late final _spine_animation_state_add_empty_animationPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function(spine_animation_state, ffi.Int32, 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)>();

  void spine_animation_state_set_empty_animations(spine_animation_state state, double mixDuration) {
    return _spine_animation_state_set_empty_animations(state, 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 state, int trackIndex) {
    return _spine_animation_state_get_current(state, trackIndex);
  }

  late final _spine_animation_state_get_currentPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function(spine_animation_state, ffi.Int32)>>(
        '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)>();

  spine_animation_state_data spine_animation_state_get_data(spine_animation_state state) {
    return _spine_animation_state_get_data(state);
  }

  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)>();

  double spine_animation_state_get_time_scale(spine_animation_state state) {
    return _spine_animation_state_get_time_scale(state);
  }

  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 state, double timeScale) {
    return _spine_animation_state_set_time_scale(state, timeScale);
  }

  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)>();

  /// OMITTED setListener()
  /// OMITTED setListener()
  /// OMITTED disableQueue()
  /// OMITTED enableQueue()
  /// OMITTED setManualTrackEntryDisposal()
  /// OMITTED getManualTrackEntryDisposal()
  void spine_animation_state_dispose_track_entry(spine_animation_state state, spine_track_entry entry) {
    return _spine_animation_state_dispose_track_entry(state, 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)>();

  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)>();

  int spine_track_entry_get_track_index(spine_track_entry entry) {
    return _spine_track_entry_get_track_index(entry);
  }

  late final _spine_track_entry_get_track_indexPtr = _lookup<ffi.NativeFunction<ffi.Int32 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)>();

  spine_animation spine_track_entry_get_animation(spine_track_entry entry) {
    return _spine_track_entry_get_animation(entry);
  }

  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)>();

  spine_track_entry spine_track_entry_get_previous(spine_track_entry entry) {
    return _spine_track_entry_get_previous(entry);
  }

  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)>();

  int spine_track_entry_get_loop(spine_track_entry entry) {
    return _spine_track_entry_get_loop(entry);
  }

  late final _spine_track_entry_get_loopPtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_track_entry)>>(
    'spine_track_entry_get_loop',
  );
  late final _spine_track_entry_get_loop = _spine_track_entry_get_loopPtr.asFunction<int Function(spine_track_entry)>();

  void spine_track_entry_set_loop(spine_track_entry entry, int loop) {
    return _spine_track_entry_set_loop(entry, loop);
  }

  late final _spine_track_entry_set_loopPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, spine_bool)>>('spine_track_entry_set_loop');
  late final _spine_track_entry_set_loop = _spine_track_entry_set_loopPtr
      .asFunction<void Function(spine_track_entry, int)>();

  int spine_track_entry_get_hold_previous(spine_track_entry entry) {
    return _spine_track_entry_get_hold_previous(entry);
  }

  late final _spine_track_entry_get_hold_previousPtr =
      _lookup<ffi.NativeFunction<spine_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<int Function(spine_track_entry)>();

  void spine_track_entry_set_hold_previous(spine_track_entry entry, int holdPrevious) {
    return _spine_track_entry_set_hold_previous(entry, holdPrevious);
  }

  late final _spine_track_entry_set_hold_previousPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, spine_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, int)>();

  int spine_track_entry_get_reverse(spine_track_entry entry) {
    return _spine_track_entry_get_reverse(entry);
  }

  late final _spine_track_entry_get_reversePtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_track_entry)>>(
    'spine_track_entry_get_reverse',
  );
  late final _spine_track_entry_get_reverse = _spine_track_entry_get_reversePtr
      .asFunction<int Function(spine_track_entry)>();

  void spine_track_entry_set_reverse(spine_track_entry entry, int reverse) {
    return _spine_track_entry_set_reverse(entry, reverse);
  }

  late final _spine_track_entry_set_reversePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, spine_bool)>>('spine_track_entry_set_reverse');
  late final _spine_track_entry_set_reverse = _spine_track_entry_set_reversePtr
      .asFunction<void Function(spine_track_entry, int)>();

  int spine_track_entry_get_shortest_rotation(spine_track_entry entry) {
    return _spine_track_entry_get_shortest_rotation(entry);
  }

  late final _spine_track_entry_get_shortest_rotationPtr =
      _lookup<ffi.NativeFunction<spine_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<int Function(spine_track_entry)>();

  void spine_track_entry_set_shortest_rotation(spine_track_entry entry, int shortestRotation) {
    return _spine_track_entry_set_shortest_rotation(entry, shortestRotation);
  }

  late final _spine_track_entry_set_shortest_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, spine_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, int)>();

  double spine_track_entry_get_delay(spine_track_entry entry) {
    return _spine_track_entry_get_delay(entry);
  }

  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 entry, double delay) {
    return _spine_track_entry_set_delay(entry, delay);
  }

  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)>();

  double spine_track_entry_get_track_time(spine_track_entry entry) {
    return _spine_track_entry_get_track_time(entry);
  }

  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 entry, double trackTime) {
    return _spine_track_entry_set_track_time(entry, trackTime);
  }

  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)>();

  double spine_track_entry_get_track_end(spine_track_entry entry) {
    return _spine_track_entry_get_track_end(entry);
  }

  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 entry, double trackEnd) {
    return _spine_track_entry_set_track_end(entry, trackEnd);
  }

  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)>();

  double spine_track_entry_get_animation_start(spine_track_entry entry) {
    return _spine_track_entry_get_animation_start(entry);
  }

  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 entry, double animationStart) {
    return _spine_track_entry_set_animation_start(entry, animationStart);
  }

  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)>();

  double spine_track_entry_get_animation_end(spine_track_entry entry) {
    return _spine_track_entry_get_animation_end(entry);
  }

  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 entry, double animationEnd) {
    return _spine_track_entry_set_animation_end(entry, animationEnd);
  }

  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)>();

  double spine_track_entry_get_animation_last(spine_track_entry entry) {
    return _spine_track_entry_get_animation_last(entry);
  }

  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 entry, double animationLast) {
    return _spine_track_entry_set_animation_last(entry, animationLast);
  }

  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)>();

  double spine_track_entry_get_animation_time(spine_track_entry entry) {
    return _spine_track_entry_get_animation_time(entry);
  }

  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)>();

  double spine_track_entry_get_time_scale(spine_track_entry entry) {
    return _spine_track_entry_get_time_scale(entry);
  }

  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 entry, double timeScale) {
    return _spine_track_entry_set_time_scale(entry, timeScale);
  }

  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)>();

  double spine_track_entry_get_alpha(spine_track_entry entry) {
    return _spine_track_entry_get_alpha(entry);
  }

  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 entry, double alpha) {
    return _spine_track_entry_set_alpha(entry, alpha);
  }

  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)>();

  double spine_track_entry_get_event_threshold(spine_track_entry entry) {
    return _spine_track_entry_get_event_threshold(entry);
  }

  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 entry, double eventThreshold) {
    return _spine_track_entry_set_event_threshold(entry, eventThreshold);
  }

  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)>();

  double spine_track_entry_get_alpha_attachment_threshold(spine_track_entry entry) {
    return _spine_track_entry_get_alpha_attachment_threshold(entry);
  }

  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 entry, double attachmentThreshold) {
    return _spine_track_entry_set_alpha_attachment_threshold(entry, attachmentThreshold);
  }

  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)>();

  double spine_track_entry_get_mix_attachment_threshold(spine_track_entry entry) {
    return _spine_track_entry_get_mix_attachment_threshold(entry);
  }

  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 entry, double attachmentThreshold) {
    return _spine_track_entry_set_mix_attachment_threshold(entry, attachmentThreshold);
  }

  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)>();

  double spine_track_entry_get_mix_draw_order_threshold(spine_track_entry entry) {
    return _spine_track_entry_get_mix_draw_order_threshold(entry);
  }

  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 entry, double drawOrderThreshold) {
    return _spine_track_entry_set_mix_draw_order_threshold(entry, drawOrderThreshold);
  }

  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 entry) {
    return _spine_track_entry_get_next(entry);
  }

  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)>();

  int spine_track_entry_is_complete(spine_track_entry entry) {
    return _spine_track_entry_is_complete(entry);
  }

  late final _spine_track_entry_is_completePtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_track_entry)>>(
    'spine_track_entry_is_complete',
  );
  late final _spine_track_entry_is_complete = _spine_track_entry_is_completePtr
      .asFunction<int Function(spine_track_entry)>();

  double spine_track_entry_get_mix_time(spine_track_entry entry) {
    return _spine_track_entry_get_mix_time(entry);
  }

  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 entry, double mixTime) {
    return _spine_track_entry_set_mix_time(entry, mixTime);
  }

  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)>();

  double spine_track_entry_get_mix_duration(spine_track_entry entry) {
    return _spine_track_entry_get_mix_duration(entry);
  }

  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(spine_track_entry entry, double mixDuration) {
    return _spine_track_entry_set_mix_duration(entry, mixDuration);
  }

  late final _spine_track_entry_set_mix_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
        'spine_track_entry_set_mix_duration',
      );
  late final _spine_track_entry_set_mix_duration = _spine_track_entry_set_mix_durationPtr
      .asFunction<void Function(spine_track_entry, double)>();

  int spine_track_entry_get_mix_blend(spine_track_entry entry) {
    return _spine_track_entry_get_mix_blend(entry);
  }

  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 entry, int mixBlend) {
    return _spine_track_entry_set_mix_blend(entry, mixBlend);
  }

  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 entry) {
    return _spine_track_entry_get_mixing_from(entry);
  }

  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 entry) {
    return _spine_track_entry_get_mixing_to(entry);
  }

  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)>();

  void spine_track_entry_reset_rotation_directions(spine_track_entry entry) {
    return _spine_track_entry_reset_rotation_directions(entry);
  }

  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 entry) {
    return _spine_track_entry_get_track_complete(entry);
  }

  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)>();

  int spine_track_entry_was_applied(spine_track_entry entry) {
    return _spine_track_entry_was_applied(entry);
  }

  late final _spine_track_entry_was_appliedPtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_track_entry)>>(
    'spine_track_entry_was_applied',
  );
  late final _spine_track_entry_was_applied = _spine_track_entry_was_appliedPtr
      .asFunction<int Function(spine_track_entry)>();

  int spine_track_entry_is_next_ready(spine_track_entry entry) {
    return _spine_track_entry_is_next_ready(entry);
  }

  late final _spine_track_entry_is_next_readyPtr = _lookup<ffi.NativeFunction<spine_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<int Function(spine_track_entry)>();

  /// OMITTED setListener()
  /// OMITTED setListener()
  void spine_skeleton_update_cache(spine_skeleton skeleton) {
    return _spine_skeleton_update_cache(skeleton);
  }

  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)>();

  /// OMITTED printUpdateCache()
  void spine_skeleton_update_world_transform(spine_skeleton skeleton, int physics) {
    return _spine_skeleton_update_world_transform(skeleton, 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)>();

  void spine_skeleton_update_world_transform_bone(spine_skeleton skeleton, int physics, spine_bone parent) {
    return _spine_skeleton_update_world_transform_bone(skeleton, physics, parent);
  }

  late final _spine_skeleton_update_world_transform_bonePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Int32, spine_bone)>>(
        'spine_skeleton_update_world_transform_bone',
      );
  late final _spine_skeleton_update_world_transform_bone = _spine_skeleton_update_world_transform_bonePtr
      .asFunction<void Function(spine_skeleton, int, spine_bone)>();

  void spine_skeleton_set_to_setup_pose(spine_skeleton skeleton) {
    return _spine_skeleton_set_to_setup_pose(skeleton);
  }

  late final _spine_skeleton_set_to_setup_posePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
    'spine_skeleton_set_to_setup_pose',
  );
  late final _spine_skeleton_set_to_setup_pose = _spine_skeleton_set_to_setup_posePtr
      .asFunction<void Function(spine_skeleton)>();

  void spine_skeleton_set_bones_to_setup_pose(spine_skeleton skeleton) {
    return _spine_skeleton_set_bones_to_setup_pose(skeleton);
  }

  late final _spine_skeleton_set_bones_to_setup_posePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>('spine_skeleton_set_bones_to_setup_pose');
  late final _spine_skeleton_set_bones_to_setup_pose = _spine_skeleton_set_bones_to_setup_posePtr
      .asFunction<void Function(spine_skeleton)>();

  void spine_skeleton_set_slots_to_setup_pose(spine_skeleton skeleton) {
    return _spine_skeleton_set_slots_to_setup_pose(skeleton);
  }

  late final _spine_skeleton_set_slots_to_setup_posePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>('spine_skeleton_set_slots_to_setup_pose');
  late final _spine_skeleton_set_slots_to_setup_pose = _spine_skeleton_set_slots_to_setup_posePtr
      .asFunction<void Function(spine_skeleton)>();

  spine_bone spine_skeleton_find_bone(spine_skeleton skeleton, ffi.Pointer<utf8> boneName) {
    return _spine_skeleton_find_bone(skeleton, boneName);
  }

  late final _spine_skeleton_find_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_skeleton, ffi.Pointer<utf8>)>>('spine_skeleton_find_bone');
  late final _spine_skeleton_find_bone = _spine_skeleton_find_bonePtr
      .asFunction<spine_bone Function(spine_skeleton, ffi.Pointer<utf8>)>();

  spine_slot spine_skeleton_find_slot(spine_skeleton skeleton, ffi.Pointer<utf8> slotName) {
    return _spine_skeleton_find_slot(skeleton, slotName);
  }

  late final _spine_skeleton_find_slotPtr =
      _lookup<ffi.NativeFunction<spine_slot Function(spine_skeleton, ffi.Pointer<utf8>)>>('spine_skeleton_find_slot');
  late final _spine_skeleton_find_slot = _spine_skeleton_find_slotPtr
      .asFunction<spine_slot Function(spine_skeleton, ffi.Pointer<utf8>)>();

  void spine_skeleton_set_skin_by_name(spine_skeleton skeleton, ffi.Pointer<utf8> skinName) {
    return _spine_skeleton_set_skin_by_name(skeleton, skinName);
  }

  late final _spine_skeleton_set_skin_by_namePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Pointer<utf8>)>>(
        'spine_skeleton_set_skin_by_name',
      );
  late final _spine_skeleton_set_skin_by_name = _spine_skeleton_set_skin_by_namePtr
      .asFunction<void Function(spine_skeleton, ffi.Pointer<utf8>)>();

  void spine_skeleton_set_skin(spine_skeleton skeleton, spine_skin skin) {
    return _spine_skeleton_set_skin(skeleton, skin);
  }

  late final _spine_skeleton_set_skinPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_skin)>>(
    'spine_skeleton_set_skin',
  );
  late final _spine_skeleton_set_skin = _spine_skeleton_set_skinPtr
      .asFunction<void Function(spine_skeleton, spine_skin)>();

  spine_attachment spine_skeleton_get_attachment_by_name(
    spine_skeleton skeleton,
    ffi.Pointer<utf8> slotName,
    ffi.Pointer<utf8> attachmentName,
  ) {
    return _spine_skeleton_get_attachment_by_name(skeleton, slotName, attachmentName);
  }

  late final _spine_skeleton_get_attachment_by_namePtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_skeleton, ffi.Pointer<utf8>, ffi.Pointer<utf8>)>>(
        'spine_skeleton_get_attachment_by_name',
      );
  late final _spine_skeleton_get_attachment_by_name = _spine_skeleton_get_attachment_by_namePtr
      .asFunction<spine_attachment Function(spine_skeleton, ffi.Pointer<utf8>, ffi.Pointer<utf8>)>();

  spine_attachment spine_skeleton_get_attachment(
    spine_skeleton skeleton,
    int slotIndex,
    ffi.Pointer<utf8> attachmentName,
  ) {
    return _spine_skeleton_get_attachment(skeleton, slotIndex, attachmentName);
  }

  late final _spine_skeleton_get_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_skeleton, ffi.Int32, ffi.Pointer<utf8>)>>(
        'spine_skeleton_get_attachment',
      );
  late final _spine_skeleton_get_attachment = _spine_skeleton_get_attachmentPtr
      .asFunction<spine_attachment Function(spine_skeleton, int, ffi.Pointer<utf8>)>();

  void spine_skeleton_set_attachment(
    spine_skeleton skeleton,
    ffi.Pointer<utf8> slotName,
    ffi.Pointer<utf8> attachmentName,
  ) {
    return _spine_skeleton_set_attachment(skeleton, slotName, attachmentName);
  }

  late final _spine_skeleton_set_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Pointer<utf8>, ffi.Pointer<utf8>)>>(
        'spine_skeleton_set_attachment',
      );
  late final _spine_skeleton_set_attachment = _spine_skeleton_set_attachmentPtr
      .asFunction<void Function(spine_skeleton, ffi.Pointer<utf8>, ffi.Pointer<utf8>)>();

  spine_ik_constraint spine_skeleton_find_ik_constraint(spine_skeleton skeleton, ffi.Pointer<utf8> constraintName) {
    return _spine_skeleton_find_ik_constraint(skeleton, constraintName);
  }

  late final _spine_skeleton_find_ik_constraintPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint Function(spine_skeleton, ffi.Pointer<utf8>)>>(
        'spine_skeleton_find_ik_constraint',
      );
  late final _spine_skeleton_find_ik_constraint = _spine_skeleton_find_ik_constraintPtr
      .asFunction<spine_ik_constraint Function(spine_skeleton, ffi.Pointer<utf8>)>();

  spine_transform_constraint spine_skeleton_find_transform_constraint(
    spine_skeleton skeleton,
    ffi.Pointer<utf8> constraintName,
  ) {
    return _spine_skeleton_find_transform_constraint(skeleton, constraintName);
  }

  late final _spine_skeleton_find_transform_constraintPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint Function(spine_skeleton, ffi.Pointer<utf8>)>>(
        'spine_skeleton_find_transform_constraint',
      );
  late final _spine_skeleton_find_transform_constraint = _spine_skeleton_find_transform_constraintPtr
      .asFunction<spine_transform_constraint Function(spine_skeleton, ffi.Pointer<utf8>)>();

  spine_path_constraint spine_skeleton_find_path_constraint(spine_skeleton skeleton, ffi.Pointer<utf8> constraintName) {
    return _spine_skeleton_find_path_constraint(skeleton, constraintName);
  }

  late final _spine_skeleton_find_path_constraintPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint Function(spine_skeleton, ffi.Pointer<utf8>)>>(
        'spine_skeleton_find_path_constraint',
      );
  late final _spine_skeleton_find_path_constraint = _spine_skeleton_find_path_constraintPtr
      .asFunction<spine_path_constraint Function(spine_skeleton, ffi.Pointer<utf8>)>();

  spine_physics_constraint spine_skeleton_find_physics_constraint(
    spine_skeleton skeleton,
    ffi.Pointer<utf8> constraintName,
  ) {
    return _spine_skeleton_find_physics_constraint(skeleton, constraintName);
  }

  late final _spine_skeleton_find_physics_constraintPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint Function(spine_skeleton, ffi.Pointer<utf8>)>>(
        'spine_skeleton_find_physics_constraint',
      );
  late final _spine_skeleton_find_physics_constraint = _spine_skeleton_find_physics_constraintPtr
      .asFunction<spine_physics_constraint Function(spine_skeleton, ffi.Pointer<utf8>)>();

  spine_bounds spine_skeleton_get_bounds(spine_skeleton skeleton) {
    return _spine_skeleton_get_bounds(skeleton);
  }

  late final _spine_skeleton_get_boundsPtr = _lookup<ffi.NativeFunction<spine_bounds Function(spine_skeleton)>>(
    'spine_skeleton_get_bounds',
  );
  late final _spine_skeleton_get_bounds = _spine_skeleton_get_boundsPtr
      .asFunction<spine_bounds Function(spine_skeleton)>();

  spine_bone spine_skeleton_get_root_bone(spine_skeleton skeleton) {
    return _spine_skeleton_get_root_bone(skeleton);
  }

  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_skeleton_data spine_skeleton_get_data(spine_skeleton skeleton) {
    return _spine_skeleton_get_data(skeleton);
  }

  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)>();

  int spine_skeleton_get_num_bones(spine_skeleton skeleton) {
    return _spine_skeleton_get_num_bones(skeleton);
  }

  late final _spine_skeleton_get_num_bonesPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
    'spine_skeleton_get_num_bones',
  );
  late final _spine_skeleton_get_num_bones = _spine_skeleton_get_num_bonesPtr
      .asFunction<int Function(spine_skeleton)>();

  ffi.Pointer<spine_bone> spine_skeleton_get_bones(spine_skeleton skeleton) {
    return _spine_skeleton_get_bones(skeleton);
  }

  late final _spine_skeleton_get_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_bone> Function(spine_skeleton)>>('spine_skeleton_get_bones');
  late final _spine_skeleton_get_bones = _spine_skeleton_get_bonesPtr
      .asFunction<ffi.Pointer<spine_bone> Function(spine_skeleton)>();

  /// OMITTED getUpdateCacheList()
  int spine_skeleton_get_num_slots(spine_skeleton skeleton) {
    return _spine_skeleton_get_num_slots(skeleton);
  }

  late final _spine_skeleton_get_num_slotsPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
    'spine_skeleton_get_num_slots',
  );
  late final _spine_skeleton_get_num_slots = _spine_skeleton_get_num_slotsPtr
      .asFunction<int Function(spine_skeleton)>();

  ffi.Pointer<spine_slot> spine_skeleton_get_slots(spine_skeleton skeleton) {
    return _spine_skeleton_get_slots(skeleton);
  }

  late final _spine_skeleton_get_slotsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_slot> Function(spine_skeleton)>>('spine_skeleton_get_slots');
  late final _spine_skeleton_get_slots = _spine_skeleton_get_slotsPtr
      .asFunction<ffi.Pointer<spine_slot> Function(spine_skeleton)>();

  int spine_skeleton_get_num_draw_order(spine_skeleton skeleton) {
    return _spine_skeleton_get_num_draw_order(skeleton);
  }

  late final _spine_skeleton_get_num_draw_orderPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
    'spine_skeleton_get_num_draw_order',
  );
  late final _spine_skeleton_get_num_draw_order = _spine_skeleton_get_num_draw_orderPtr
      .asFunction<int Function(spine_skeleton)>();

  ffi.Pointer<spine_slot> spine_skeleton_get_draw_order(spine_skeleton skeleton) {
    return _spine_skeleton_get_draw_order(skeleton);
  }

  late final _spine_skeleton_get_draw_orderPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_slot> Function(spine_skeleton)>>('spine_skeleton_get_draw_order');
  late final _spine_skeleton_get_draw_order = _spine_skeleton_get_draw_orderPtr
      .asFunction<ffi.Pointer<spine_slot> Function(spine_skeleton)>();

  int spine_skeleton_get_num_ik_constraints(spine_skeleton skeleton) {
    return _spine_skeleton_get_num_ik_constraints(skeleton);
  }

  late final _spine_skeleton_get_num_ik_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>('spine_skeleton_get_num_ik_constraints');
  late final _spine_skeleton_get_num_ik_constraints = _spine_skeleton_get_num_ik_constraintsPtr
      .asFunction<int Function(spine_skeleton)>();

  ffi.Pointer<spine_ik_constraint> spine_skeleton_get_ik_constraints(spine_skeleton skeleton) {
    return _spine_skeleton_get_ik_constraints(skeleton);
  }

  late final _spine_skeleton_get_ik_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_ik_constraint> Function(spine_skeleton)>>(
        'spine_skeleton_get_ik_constraints',
      );
  late final _spine_skeleton_get_ik_constraints = _spine_skeleton_get_ik_constraintsPtr
      .asFunction<ffi.Pointer<spine_ik_constraint> Function(spine_skeleton)>();

  int spine_skeleton_get_num_transform_constraints(spine_skeleton skeleton) {
    return _spine_skeleton_get_num_transform_constraints(skeleton);
  }

  late final _spine_skeleton_get_num_transform_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>('spine_skeleton_get_num_transform_constraints');
  late final _spine_skeleton_get_num_transform_constraints = _spine_skeleton_get_num_transform_constraintsPtr
      .asFunction<int Function(spine_skeleton)>();

  ffi.Pointer<spine_transform_constraint> spine_skeleton_get_transform_constraints(spine_skeleton skeleton) {
    return _spine_skeleton_get_transform_constraints(skeleton);
  }

  late final _spine_skeleton_get_transform_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_transform_constraint> Function(spine_skeleton)>>(
        'spine_skeleton_get_transform_constraints',
      );
  late final _spine_skeleton_get_transform_constraints = _spine_skeleton_get_transform_constraintsPtr
      .asFunction<ffi.Pointer<spine_transform_constraint> Function(spine_skeleton)>();

  int spine_skeleton_get_num_path_constraints(spine_skeleton skeleton) {
    return _spine_skeleton_get_num_path_constraints(skeleton);
  }

  late final _spine_skeleton_get_num_path_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>('spine_skeleton_get_num_path_constraints');
  late final _spine_skeleton_get_num_path_constraints = _spine_skeleton_get_num_path_constraintsPtr
      .asFunction<int Function(spine_skeleton)>();

  ffi.Pointer<spine_path_constraint> spine_skeleton_get_path_constraints(spine_skeleton skeleton) {
    return _spine_skeleton_get_path_constraints(skeleton);
  }

  late final _spine_skeleton_get_path_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_path_constraint> Function(spine_skeleton)>>(
        'spine_skeleton_get_path_constraints',
      );
  late final _spine_skeleton_get_path_constraints = _spine_skeleton_get_path_constraintsPtr
      .asFunction<ffi.Pointer<spine_path_constraint> Function(spine_skeleton)>();

  int spine_skeleton_get_num_physics_constraints(spine_skeleton skeleton) {
    return _spine_skeleton_get_num_physics_constraints(skeleton);
  }

  late final _spine_skeleton_get_num_physics_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>('spine_skeleton_get_num_physics_constraints');
  late final _spine_skeleton_get_num_physics_constraints = _spine_skeleton_get_num_physics_constraintsPtr
      .asFunction<int Function(spine_skeleton)>();

  ffi.Pointer<spine_physics_constraint> spine_skeleton_get_physics_constraints(spine_skeleton skeleton) {
    return _spine_skeleton_get_physics_constraints(skeleton);
  }

  late final _spine_skeleton_get_physics_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_physics_constraint> Function(spine_skeleton)>>(
        'spine_skeleton_get_physics_constraints',
      );
  late final _spine_skeleton_get_physics_constraints = _spine_skeleton_get_physics_constraintsPtr
      .asFunction<ffi.Pointer<spine_physics_constraint> Function(spine_skeleton)>();

  spine_skin spine_skeleton_get_skin(spine_skeleton skeleton) {
    return _spine_skeleton_get_skin(skeleton);
  }

  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)>();

  spine_color spine_skeleton_get_color(spine_skeleton skeleton) {
    return _spine_skeleton_get_color(skeleton);
  }

  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(spine_skeleton skeleton, double r, double g, double b, double a) {
    return _spine_skeleton_set_color(skeleton, r, g, b, a);
  }

  late final _spine_skeleton_set_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
        'spine_skeleton_set_color',
      );
  late final _spine_skeleton_set_color = _spine_skeleton_set_colorPtr
      .asFunction<void Function(spine_skeleton, double, double, double, double)>();

  void spine_skeleton_set_position(spine_skeleton skeleton, double x, double y) {
    return _spine_skeleton_set_position(skeleton, 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)>();

  double spine_skeleton_get_x(spine_skeleton skeleton) {
    return _spine_skeleton_get_x(skeleton);
  }

  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 skeleton, double x) {
    return _spine_skeleton_set_x(skeleton, x);
  }

  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 skeleton) {
    return _spine_skeleton_get_y(skeleton);
  }

  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 skeleton, double y) {
    return _spine_skeleton_set_y(skeleton, y);
  }

  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)>();

  double spine_skeleton_get_scale_x(spine_skeleton skeleton) {
    return _spine_skeleton_get_scale_x(skeleton);
  }

  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 skeleton, double scaleX) {
    return _spine_skeleton_set_scale_x(skeleton, scaleX);
  }

  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 skeleton) {
    return _spine_skeleton_get_scale_y(skeleton);
  }

  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 skeleton, double scaleY) {
    return _spine_skeleton_set_scale_y(skeleton, scaleY);
  }

  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)>();

  double spine_skeleton_get_time(spine_skeleton skeleton) {
    return _spine_skeleton_get_time(skeleton);
  }

  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 skeleton, double time) {
    return _spine_skeleton_set_time(skeleton, 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 skeleton, double delta) {
    return _spine_skeleton_update(skeleton, 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)>();

  ffi.Pointer<utf8> spine_event_data_get_name(spine_event_data event) {
    return _spine_event_data_get_name(event);
  }

  late final _spine_event_data_get_namePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_event_data)>>(
    'spine_event_data_get_name',
  );
  late final _spine_event_data_get_name = _spine_event_data_get_namePtr
      .asFunction<ffi.Pointer<utf8> Function(spine_event_data)>();

  int spine_event_data_get_int_value(spine_event_data event) {
    return _spine_event_data_get_int_value(event);
  }

  late final _spine_event_data_get_int_valuePtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_event_data)>>(
    'spine_event_data_get_int_value',
  );
  late final _spine_event_data_get_int_value = _spine_event_data_get_int_valuePtr
      .asFunction<int Function(spine_event_data)>();

  void spine_event_data_set_int_value(spine_event_data event, int value) {
    return _spine_event_data_set_int_value(event, value);
  }

  late final _spine_event_data_set_int_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Int32)>>('spine_event_data_set_int_value');
  late final _spine_event_data_set_int_value = _spine_event_data_set_int_valuePtr
      .asFunction<void Function(spine_event_data, int)>();

  double spine_event_data_get_float_value(spine_event_data event) {
    return _spine_event_data_get_float_value(event);
  }

  late final _spine_event_data_get_float_valuePtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_event_data)>>(
    'spine_event_data_get_float_value',
  );
  late final _spine_event_data_get_float_value = _spine_event_data_get_float_valuePtr
      .asFunction<double Function(spine_event_data)>();

  void spine_event_data_set_float_value(spine_event_data event, double value) {
    return _spine_event_data_set_float_value(event, value);
  }

  late final _spine_event_data_set_float_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Float)>>('spine_event_data_set_float_value');
  late final _spine_event_data_set_float_value = _spine_event_data_set_float_valuePtr
      .asFunction<void Function(spine_event_data, double)>();

  ffi.Pointer<utf8> spine_event_data_get_string_value(spine_event_data event) {
    return _spine_event_data_get_string_value(event);
  }

  late final _spine_event_data_get_string_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_event_data)>>('spine_event_data_get_string_value');
  late final _spine_event_data_get_string_value = _spine_event_data_get_string_valuePtr
      .asFunction<ffi.Pointer<utf8> Function(spine_event_data)>();

  void spine_event_data_set_string_value(spine_event_data event, ffi.Pointer<utf8> value) {
    return _spine_event_data_set_string_value(event, value);
  }

  late final _spine_event_data_set_string_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Pointer<utf8>)>>(
        'spine_event_data_set_string_value',
      );
  late final _spine_event_data_set_string_value = _spine_event_data_set_string_valuePtr
      .asFunction<void Function(spine_event_data, ffi.Pointer<utf8>)>();

  ffi.Pointer<utf8> spine_event_data_get_audio_path(spine_event_data event) {
    return _spine_event_data_get_audio_path(event);
  }

  late final _spine_event_data_get_audio_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<utf8> 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<utf8> Function(spine_event_data)>();

  /// OMITTED setAudioPath()
  double spine_event_data_get_volume(spine_event_data event) {
    return _spine_event_data_get_volume(event);
  }

  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 event, double volume) {
    return _spine_event_data_set_volume(event, volume);
  }

  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 event) {
    return _spine_event_data_get_balance(event);
  }

  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 event, double balance) {
    return _spine_event_data_set_balance(event, balance);
  }

  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_data spine_event_get_data(spine_event event) {
    return _spine_event_get_data(event);
  }

  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)>();

  double spine_event_get_time(spine_event event) {
    return _spine_event_get_time(event);
  }

  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_value(spine_event event) {
    return _spine_event_get_int_value(event);
  }

  late final _spine_event_get_int_valuePtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_event)>>(
    'spine_event_get_int_value',
  );
  late final _spine_event_get_int_value = _spine_event_get_int_valuePtr.asFunction<int Function(spine_event)>();

  void spine_event_set_int_value(spine_event event, int value) {
    return _spine_event_set_int_value(event, value);
  }

  late final _spine_event_set_int_valuePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Int32)>>(
    'spine_event_set_int_value',
  );
  late final _spine_event_set_int_value = _spine_event_set_int_valuePtr.asFunction<void Function(spine_event, int)>();

  double spine_event_get_float_value(spine_event event) {
    return _spine_event_get_float_value(event);
  }

  late final _spine_event_get_float_valuePtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
    'spine_event_get_float_value',
  );
  late final _spine_event_get_float_value = _spine_event_get_float_valuePtr.asFunction<double Function(spine_event)>();

  void spine_event_set_float_value(spine_event event, double value) {
    return _spine_event_set_float_value(event, value);
  }

  late final _spine_event_set_float_valuePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Float)>>(
    'spine_event_set_float_value',
  );
  late final _spine_event_set_float_value = _spine_event_set_float_valuePtr
      .asFunction<void Function(spine_event, double)>();

  ffi.Pointer<utf8> spine_event_get_string_value(spine_event event) {
    return _spine_event_get_string_value(event);
  }

  late final _spine_event_get_string_valuePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_event)>>(
    'spine_event_get_string_value',
  );
  late final _spine_event_get_string_value = _spine_event_get_string_valuePtr
      .asFunction<ffi.Pointer<utf8> Function(spine_event)>();

  void spine_event_set_string_value(spine_event event, ffi.Pointer<utf8> value) {
    return _spine_event_set_string_value(event, value);
  }

  late final _spine_event_set_string_valuePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Pointer<utf8>)>>('spine_event_set_string_value');
  late final _spine_event_set_string_value = _spine_event_set_string_valuePtr
      .asFunction<void Function(spine_event, ffi.Pointer<utf8>)>();

  double spine_event_get_volume(spine_event event) {
    return _spine_event_get_volume(event);
  }

  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 event, double volume) {
    return _spine_event_set_volume(event, volume);
  }

  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 event) {
    return _spine_event_get_balance(event);
  }

  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 event, double balance) {
    return _spine_event_set_balance(event, balance);
  }

  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)>();

  int spine_slot_data_get_index(spine_slot_data slot) {
    return _spine_slot_data_get_index(slot);
  }

  late final _spine_slot_data_get_indexPtr = _lookup<ffi.NativeFunction<ffi.Int32 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)>();

  ffi.Pointer<utf8> spine_slot_data_get_name(spine_slot_data slot) {
    return _spine_slot_data_get_name(slot);
  }

  late final _spine_slot_data_get_namePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_slot_data)>>(
    'spine_slot_data_get_name',
  );
  late final _spine_slot_data_get_name = _spine_slot_data_get_namePtr
      .asFunction<ffi.Pointer<utf8> Function(spine_slot_data)>();

  spine_bone_data spine_slot_data_get_bone_data(spine_slot_data slot) {
    return _spine_slot_data_get_bone_data(slot);
  }

  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)>();

  spine_color spine_slot_data_get_color(spine_slot_data slot) {
    return _spine_slot_data_get_color(slot);
  }

  late final _spine_slot_data_get_colorPtr = _lookup<ffi.NativeFunction<spine_color Function(spine_slot_data)>>(
    'spine_slot_data_get_color',
  );
  late final _spine_slot_data_get_color = _spine_slot_data_get_colorPtr
      .asFunction<spine_color Function(spine_slot_data)>();

  void spine_slot_data_set_color(spine_slot_data slot, double r, double g, double b, double a) {
    return _spine_slot_data_set_color(slot, r, g, b, a);
  }

  late final _spine_slot_data_set_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
        'spine_slot_data_set_color',
      );
  late final _spine_slot_data_set_color = _spine_slot_data_set_colorPtr
      .asFunction<void Function(spine_slot_data, double, double, double, double)>();

  spine_color spine_slot_data_get_dark_color(spine_slot_data slot) {
    return _spine_slot_data_get_dark_color(slot);
  }

  late final _spine_slot_data_get_dark_colorPtr = _lookup<ffi.NativeFunction<spine_color Function(spine_slot_data)>>(
    'spine_slot_data_get_dark_color',
  );
  late final _spine_slot_data_get_dark_color = _spine_slot_data_get_dark_colorPtr
      .asFunction<spine_color Function(spine_slot_data)>();

  void spine_slot_data_set_dark_color(spine_slot_data slot, double r, double g, double b, double a) {
    return _spine_slot_data_set_dark_color(slot, r, g, b, a);
  }

  late final _spine_slot_data_set_dark_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
        'spine_slot_data_set_dark_color',
      );
  late final _spine_slot_data_set_dark_color = _spine_slot_data_set_dark_colorPtr
      .asFunction<void Function(spine_slot_data, double, double, double, double)>();

  int spine_slot_data_has_dark_color(spine_slot_data slot) {
    return _spine_slot_data_has_dark_color(slot);
  }

  late final _spine_slot_data_has_dark_colorPtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_slot_data)>>(
    'spine_slot_data_has_dark_color',
  );
  late final _spine_slot_data_has_dark_color = _spine_slot_data_has_dark_colorPtr
      .asFunction<int Function(spine_slot_data)>();

  void spine_slot_data_set_has_dark_color(spine_slot_data slot, int hasDarkColor) {
    return _spine_slot_data_set_has_dark_color(slot, hasDarkColor);
  }

  late final _spine_slot_data_set_has_dark_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, spine_bool)>>('spine_slot_data_set_has_dark_color');
  late final _spine_slot_data_set_has_dark_color = _spine_slot_data_set_has_dark_colorPtr
      .asFunction<void Function(spine_slot_data, int)>();

  ffi.Pointer<utf8> spine_slot_data_get_attachment_name(spine_slot_data slot) {
    return _spine_slot_data_get_attachment_name(slot);
  }

  late final _spine_slot_data_get_attachment_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<utf8> 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<utf8> Function(spine_slot_data)>();

  void spine_slot_data_set_attachment_name(spine_slot_data slot, ffi.Pointer<utf8> attachmentName) {
    return _spine_slot_data_set_attachment_name(slot, attachmentName);
  }

  late final _spine_slot_data_set_attachment_namePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Pointer<utf8>)>>(
        '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<utf8>)>();

  int spine_slot_data_get_blend_mode(spine_slot_data slot) {
    return _spine_slot_data_get_blend_mode(slot);
  }

  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 slot, int blendMode) {
    return _spine_slot_data_set_blend_mode(slot, 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)>();

  int spine_slot_data_is_visible(spine_slot_data slot) {
    return _spine_slot_data_is_visible(slot);
  }

  late final _spine_slot_data_is_visiblePtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_slot_data)>>(
    'spine_slot_data_is_visible',
  );
  late final _spine_slot_data_is_visible = _spine_slot_data_is_visiblePtr.asFunction<int Function(spine_slot_data)>();

  void spine_slot_data_set_visible(spine_slot_data slot, int visible) {
    return _spine_slot_data_set_visible(slot, visible);
  }

  late final _spine_slot_data_set_visiblePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, spine_bool)>>('spine_slot_data_set_visible');
  late final _spine_slot_data_set_visible = _spine_slot_data_set_visiblePtr
      .asFunction<void Function(spine_slot_data, int)>();

  /// OMITTED getPath()/setPath()
  void spine_slot_set_to_setup_pose(spine_slot slot) {
    return _spine_slot_set_to_setup_pose(slot);
  }

  late final _spine_slot_set_to_setup_posePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot)>>(
    'spine_slot_set_to_setup_pose',
  );
  late final _spine_slot_set_to_setup_pose = _spine_slot_set_to_setup_posePtr.asFunction<void Function(spine_slot)>();

  spine_slot_data spine_slot_get_data(spine_slot slot) {
    return _spine_slot_get_data(slot);
  }

  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_bone spine_slot_get_bone(spine_slot slot) {
    return _spine_slot_get_bone(slot);
  }

  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)>();

  spine_skeleton spine_slot_get_skeleton(spine_slot slot) {
    return _spine_slot_get_skeleton(slot);
  }

  late final _spine_slot_get_skeletonPtr = _lookup<ffi.NativeFunction<spine_skeleton Function(spine_slot)>>(
    'spine_slot_get_skeleton',
  );
  late final _spine_slot_get_skeleton = _spine_slot_get_skeletonPtr.asFunction<spine_skeleton Function(spine_slot)>();

  spine_color spine_slot_get_color(spine_slot slot) {
    return _spine_slot_get_color(slot);
  }

  late final _spine_slot_get_colorPtr = _lookup<ffi.NativeFunction<spine_color Function(spine_slot)>>(
    'spine_slot_get_color',
  );
  late final _spine_slot_get_color = _spine_slot_get_colorPtr.asFunction<spine_color Function(spine_slot)>();

  void spine_slot_set_color(spine_slot slot, double r, double g, double b, double a) {
    return _spine_slot_set_color(slot, r, g, b, a);
  }

  late final _spine_slot_set_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
        'spine_slot_set_color',
      );
  late final _spine_slot_set_color = _spine_slot_set_colorPtr
      .asFunction<void Function(spine_slot, double, double, double, double)>();

  spine_color spine_slot_get_dark_color(spine_slot slot) {
    return _spine_slot_get_dark_color(slot);
  }

  late final _spine_slot_get_dark_colorPtr = _lookup<ffi.NativeFunction<spine_color Function(spine_slot)>>(
    'spine_slot_get_dark_color',
  );
  late final _spine_slot_get_dark_color = _spine_slot_get_dark_colorPtr.asFunction<spine_color Function(spine_slot)>();

  void spine_slot_set_dark_color(spine_slot slot, double r, double g, double b, double a) {
    return _spine_slot_set_dark_color(slot, r, g, b, a);
  }

  late final _spine_slot_set_dark_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
        'spine_slot_set_dark_color',
      );
  late final _spine_slot_set_dark_color = _spine_slot_set_dark_colorPtr
      .asFunction<void Function(spine_slot, double, double, double, double)>();

  int spine_slot_has_dark_color(spine_slot slot) {
    return _spine_slot_has_dark_color(slot);
  }

  late final _spine_slot_has_dark_colorPtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_slot)>>(
    'spine_slot_has_dark_color',
  );
  late final _spine_slot_has_dark_color = _spine_slot_has_dark_colorPtr.asFunction<int Function(spine_slot)>();

  spine_attachment spine_slot_get_attachment(spine_slot slot) {
    return _spine_slot_get_attachment(slot);
  }

  late final _spine_slot_get_attachmentPtr = _lookup<ffi.NativeFunction<spine_attachment Function(spine_slot)>>(
    'spine_slot_get_attachment',
  );
  late final _spine_slot_get_attachment = _spine_slot_get_attachmentPtr
      .asFunction<spine_attachment Function(spine_slot)>();

  void spine_slot_set_attachment(spine_slot slot, spine_attachment attachment) {
    return _spine_slot_set_attachment(slot, attachment);
  }

  late final _spine_slot_set_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot, spine_attachment)>>('spine_slot_set_attachment');
  late final _spine_slot_set_attachment = _spine_slot_set_attachmentPtr
      .asFunction<void Function(spine_slot, spine_attachment)>();

  /// OMITTED getDeform()
  int spine_slot_get_sequence_index(spine_slot slot) {
    return _spine_slot_get_sequence_index(slot);
  }

  late final _spine_slot_get_sequence_indexPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_slot)>>(
    'spine_slot_get_sequence_index',
  );
  late final _spine_slot_get_sequence_index = _spine_slot_get_sequence_indexPtr.asFunction<int Function(spine_slot)>();

  void spine_slot_set_sequence_index(spine_slot slot, int sequenceIndex) {
    return _spine_slot_set_sequence_index(slot, sequenceIndex);
  }

  late final _spine_slot_set_sequence_indexPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot, ffi.Int32)>>(
    'spine_slot_set_sequence_index',
  );
  late final _spine_slot_set_sequence_index = _spine_slot_set_sequence_indexPtr
      .asFunction<void Function(spine_slot, int)>();

  int spine_bone_data_get_index(spine_bone_data data) {
    return _spine_bone_data_get_index(data);
  }

  late final _spine_bone_data_get_indexPtr = _lookup<ffi.NativeFunction<ffi.Int32 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)>();

  ffi.Pointer<utf8> spine_bone_data_get_name(spine_bone_data data) {
    return _spine_bone_data_get_name(data);
  }

  late final _spine_bone_data_get_namePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_bone_data)>>(
    'spine_bone_data_get_name',
  );
  late final _spine_bone_data_get_name = _spine_bone_data_get_namePtr
      .asFunction<ffi.Pointer<utf8> Function(spine_bone_data)>();

  spine_bone_data spine_bone_data_get_parent(spine_bone_data data) {
    return _spine_bone_data_get_parent(data);
  }

  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 data) {
    return _spine_bone_data_get_length(data);
  }

  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 data, double length) {
    return _spine_bone_data_set_length(data, length);
  }

  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)>();

  double spine_bone_data_get_x(spine_bone_data data) {
    return _spine_bone_data_get_x(data);
  }

  late final _spine_bone_data_get_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
    'spine_bone_data_get_x',
  );
  late final _spine_bone_data_get_x = _spine_bone_data_get_xPtr.asFunction<double Function(spine_bone_data)>();

  void spine_bone_data_set_x(spine_bone_data data, double x) {
    return _spine_bone_data_set_x(data, x);
  }

  late final _spine_bone_data_set_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>(
    'spine_bone_data_set_x',
  );
  late final _spine_bone_data_set_x = _spine_bone_data_set_xPtr.asFunction<void Function(spine_bone_data, double)>();

  double spine_bone_data_get_y(spine_bone_data data) {
    return _spine_bone_data_get_y(data);
  }

  late final _spine_bone_data_get_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
    'spine_bone_data_get_y',
  );
  late final _spine_bone_data_get_y = _spine_bone_data_get_yPtr.asFunction<double Function(spine_bone_data)>();

  void spine_bone_data_set_y(spine_bone_data data, double y) {
    return _spine_bone_data_set_y(data, y);
  }

  late final _spine_bone_data_set_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>(
    'spine_bone_data_set_y',
  );
  late final _spine_bone_data_set_y = _spine_bone_data_set_yPtr.asFunction<void Function(spine_bone_data, double)>();

  double spine_bone_data_get_rotation(spine_bone_data data) {
    return _spine_bone_data_get_rotation(data);
  }

  late final _spine_bone_data_get_rotationPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
    'spine_bone_data_get_rotation',
  );
  late final _spine_bone_data_get_rotation = _spine_bone_data_get_rotationPtr
      .asFunction<double Function(spine_bone_data)>();

  void spine_bone_data_set_rotation(spine_bone_data data, double rotation) {
    return _spine_bone_data_set_rotation(data, rotation);
  }

  late final _spine_bone_data_set_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>('spine_bone_data_set_rotation');
  late final _spine_bone_data_set_rotation = _spine_bone_data_set_rotationPtr
      .asFunction<void Function(spine_bone_data, double)>();

  double spine_bone_data_get_scale_x(spine_bone_data data) {
    return _spine_bone_data_get_scale_x(data);
  }

  late final _spine_bone_data_get_scale_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
    'spine_bone_data_get_scale_x',
  );
  late final _spine_bone_data_get_scale_x = _spine_bone_data_get_scale_xPtr
      .asFunction<double Function(spine_bone_data)>();

  void spine_bone_data_set_scale_x(spine_bone_data data, double scaleX) {
    return _spine_bone_data_set_scale_x(data, scaleX);
  }

  late final _spine_bone_data_set_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>('spine_bone_data_set_scale_x');
  late final _spine_bone_data_set_scale_x = _spine_bone_data_set_scale_xPtr
      .asFunction<void Function(spine_bone_data, double)>();

  double spine_bone_data_get_scale_y(spine_bone_data data) {
    return _spine_bone_data_get_scale_y(data);
  }

  late final _spine_bone_data_get_scale_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
    'spine_bone_data_get_scale_y',
  );
  late final _spine_bone_data_get_scale_y = _spine_bone_data_get_scale_yPtr
      .asFunction<double Function(spine_bone_data)>();

  void spine_bone_data_set_scale_y(spine_bone_data data, double scaleY) {
    return _spine_bone_data_set_scale_y(data, scaleY);
  }

  late final _spine_bone_data_set_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>('spine_bone_data_set_scale_y');
  late final _spine_bone_data_set_scale_y = _spine_bone_data_set_scale_yPtr
      .asFunction<void Function(spine_bone_data, double)>();

  double spine_bone_data_get_shear_x(spine_bone_data data) {
    return _spine_bone_data_get_shear_x(data);
  }

  late final _spine_bone_data_get_shear_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
    'spine_bone_data_get_shear_x',
  );
  late final _spine_bone_data_get_shear_x = _spine_bone_data_get_shear_xPtr
      .asFunction<double Function(spine_bone_data)>();

  void spine_bone_data_set_shear_x(spine_bone_data data, double shearx) {
    return _spine_bone_data_set_shear_x(data, shearx);
  }

  late final _spine_bone_data_set_shear_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>('spine_bone_data_set_shear_x');
  late final _spine_bone_data_set_shear_x = _spine_bone_data_set_shear_xPtr
      .asFunction<void Function(spine_bone_data, double)>();

  double spine_bone_data_get_shear_y(spine_bone_data data) {
    return _spine_bone_data_get_shear_y(data);
  }

  late final _spine_bone_data_get_shear_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
    'spine_bone_data_get_shear_y',
  );
  late final _spine_bone_data_get_shear_y = _spine_bone_data_get_shear_yPtr
      .asFunction<double Function(spine_bone_data)>();

  void spine_bone_data_set_shear_y(spine_bone_data data, double shearY) {
    return _spine_bone_data_set_shear_y(data, shearY);
  }

  late final _spine_bone_data_set_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>('spine_bone_data_set_shear_y');
  late final _spine_bone_data_set_shear_y = _spine_bone_data_set_shear_yPtr
      .asFunction<void Function(spine_bone_data, double)>();

  int spine_bone_data_get_inherit(spine_bone_data data) {
    return _spine_bone_data_get_inherit(data);
  }

  late final _spine_bone_data_get_inheritPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_bone_data)>>(
    'spine_bone_data_get_inherit',
  );
  late final _spine_bone_data_get_inherit = _spine_bone_data_get_inheritPtr.asFunction<int Function(spine_bone_data)>();

  void spine_bone_data_set_inherit(spine_bone_data data, int inherit) {
    return _spine_bone_data_set_inherit(data, inherit);
  }

  late final _spine_bone_data_set_inheritPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Int32)>>('spine_bone_data_set_inherit');
  late final _spine_bone_data_set_inherit = _spine_bone_data_set_inheritPtr
      .asFunction<void Function(spine_bone_data, int)>();

  int spine_bone_data_is_skin_required(spine_bone_data data) {
    return _spine_bone_data_is_skin_required(data);
  }

  late final _spine_bone_data_is_skin_requiredPtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_bone_data)>>(
    'spine_bone_data_is_skin_required',
  );
  late final _spine_bone_data_is_skin_required = _spine_bone_data_is_skin_requiredPtr
      .asFunction<int Function(spine_bone_data)>();

  void spine_bone_data_set_is_skin_required(spine_bone_data data, int isSkinRequired) {
    return _spine_bone_data_set_is_skin_required(data, isSkinRequired);
  }

  late final _spine_bone_data_set_is_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, spine_bool)>>(
        'spine_bone_data_set_is_skin_required',
      );
  late final _spine_bone_data_set_is_skin_required = _spine_bone_data_set_is_skin_requiredPtr
      .asFunction<void Function(spine_bone_data, int)>();

  spine_color spine_bone_data_get_color(spine_bone_data data) {
    return _spine_bone_data_get_color(data);
  }

  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)>();

  void spine_bone_data_set_color(spine_bone_data data, double r, double g, double b, double a) {
    return _spine_bone_data_set_color(data, r, g, b, a);
  }

  late final _spine_bone_data_set_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
        'spine_bone_data_set_color',
      );
  late final _spine_bone_data_set_color = _spine_bone_data_set_colorPtr
      .asFunction<void Function(spine_bone_data, double, double, double, double)>();

  int spine_bone_data_is_visible(spine_bone_data data) {
    return _spine_bone_data_is_visible(data);
  }

  late final _spine_bone_data_is_visiblePtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_bone_data)>>(
    'spine_bone_data_is_visible',
  );
  late final _spine_bone_data_is_visible = _spine_bone_data_is_visiblePtr.asFunction<int Function(spine_bone_data)>();

  void spine_bone_data_set_visible(spine_bone_data data, int isVisible) {
    return _spine_bone_data_set_visible(data, isVisible);
  }

  late final _spine_bone_data_set_visiblePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, spine_bool)>>('spine_bone_data_set_visible');
  late final _spine_bone_data_set_visible = _spine_bone_data_set_visiblePtr
      .asFunction<void Function(spine_bone_data, int)>();

  /// Omitted getIcon()/setIcon()
  void spine_bone_set_is_y_down(int yDown) {
    return _spine_bone_set_is_y_down(yDown);
  }

  late final _spine_bone_set_is_y_downPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bool)>>(
    'spine_bone_set_is_y_down',
  );
  late final _spine_bone_set_is_y_down = _spine_bone_set_is_y_downPtr.asFunction<void Function(int)>();

  int spine_bone_get_is_y_down() {
    return _spine_bone_get_is_y_down();
  }

  late final _spine_bone_get_is_y_downPtr = _lookup<ffi.NativeFunction<spine_bool Function()>>(
    'spine_bone_get_is_y_down',
  );
  late final _spine_bone_get_is_y_down = _spine_bone_get_is_y_downPtr.asFunction<int Function()>();

  void spine_bone_update(spine_bone bone) {
    return _spine_bone_update(bone);
  }

  late final _spine_bone_updatePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>('spine_bone_update');
  late final _spine_bone_update = _spine_bone_updatePtr.asFunction<void Function(spine_bone)>();

  void spine_bone_update_world_transform(spine_bone bone) {
    return _spine_bone_update_world_transform(bone);
  }

  late final _spine_bone_update_world_transformPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>(
    'spine_bone_update_world_transform',
  );
  late final _spine_bone_update_world_transform = _spine_bone_update_world_transformPtr
      .asFunction<void Function(spine_bone)>();

  void spine_bone_update_world_transform_with(
    spine_bone bone,
    double x,
    double y,
    double rotation,
    double scaleX,
    double scaleY,
    double shearX,
    double shearY,
  ) {
    return _spine_bone_update_world_transform_with(bone, x, y, rotation, scaleX, scaleY, shearX, shearY);
  }

  late final _spine_bone_update_world_transform_withPtr =
      _lookup<
        ffi.NativeFunction<
          ffi.Void Function(spine_bone, ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)
        >
      >('spine_bone_update_world_transform_with');
  late final _spine_bone_update_world_transform_with = _spine_bone_update_world_transform_withPtr
      .asFunction<void Function(spine_bone, double, double, double, double, double, double, double)>();

  void spine_bone_update_applied_transform(spine_bone bone) {
    return _spine_bone_update_applied_transform(bone);
  }

  late final _spine_bone_update_applied_transformPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>(
    'spine_bone_update_applied_transform',
  );
  late final _spine_bone_update_applied_transform = _spine_bone_update_applied_transformPtr
      .asFunction<void Function(spine_bone)>();

  void spine_bone_set_to_setup_pose(spine_bone bone) {
    return _spine_bone_set_to_setup_pose(bone);
  }

  late final _spine_bone_set_to_setup_posePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>(
    'spine_bone_set_to_setup_pose',
  );
  late final _spine_bone_set_to_setup_pose = _spine_bone_set_to_setup_posePtr.asFunction<void Function(spine_bone)>();

  spine_vector spine_bone_world_to_local(spine_bone bone, double worldX, double worldY) {
    return _spine_bone_world_to_local(bone, worldX, worldY);
  }

  late final _spine_bone_world_to_localPtr =
      _lookup<ffi.NativeFunction<spine_vector Function(spine_bone, ffi.Float, ffi.Float)>>('spine_bone_world_to_local');
  late final _spine_bone_world_to_local = _spine_bone_world_to_localPtr
      .asFunction<spine_vector Function(spine_bone, double, double)>();

  spine_vector spine_bone_world_to_parent(spine_bone bone, double worldX, double worldY) {
    return _spine_bone_world_to_parent(bone, worldX, worldY);
  }

  late final _spine_bone_world_to_parentPtr =
      _lookup<ffi.NativeFunction<spine_vector Function(spine_bone, ffi.Float, ffi.Float)>>(
        'spine_bone_world_to_parent',
      );
  late final _spine_bone_world_to_parent = _spine_bone_world_to_parentPtr
      .asFunction<spine_vector Function(spine_bone, double, double)>();

  spine_vector spine_bone_local_to_world(spine_bone bone, double localX, double localY) {
    return _spine_bone_local_to_world(bone, localX, localY);
  }

  late final _spine_bone_local_to_worldPtr =
      _lookup<ffi.NativeFunction<spine_vector Function(spine_bone, ffi.Float, ffi.Float)>>('spine_bone_local_to_world');
  late final _spine_bone_local_to_world = _spine_bone_local_to_worldPtr
      .asFunction<spine_vector Function(spine_bone, double, double)>();

  spine_vector spine_bone_parent_to_world(spine_bone bone, double localX, double localY) {
    return _spine_bone_parent_to_world(bone, localX, localY);
  }

  late final _spine_bone_parent_to_worldPtr =
      _lookup<ffi.NativeFunction<spine_vector Function(spine_bone, ffi.Float, ffi.Float)>>(
        'spine_bone_parent_to_world',
      );
  late final _spine_bone_parent_to_world = _spine_bone_parent_to_worldPtr
      .asFunction<spine_vector Function(spine_bone, double, double)>();

  double spine_bone_world_to_local_rotation(spine_bone bone, double worldRotation) {
    return _spine_bone_world_to_local_rotation(bone, worldRotation);
  }

  late final _spine_bone_world_to_local_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone, ffi.Float)>>('spine_bone_world_to_local_rotation');
  late final _spine_bone_world_to_local_rotation = _spine_bone_world_to_local_rotationPtr
      .asFunction<double Function(spine_bone, double)>();

  double spine_bone_local_to_world_rotation(spine_bone bone, double localRotation) {
    return _spine_bone_local_to_world_rotation(bone, localRotation);
  }

  late final _spine_bone_local_to_world_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone, ffi.Float)>>('spine_bone_local_to_world_rotation');
  late final _spine_bone_local_to_world_rotation = _spine_bone_local_to_world_rotationPtr
      .asFunction<double Function(spine_bone, double)>();

  void spine_bone_rotate_world(spine_bone bone, double degrees) {
    return _spine_bone_rotate_world(bone, degrees);
  }

  late final _spine_bone_rotate_worldPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_rotate_world',
  );
  late final _spine_bone_rotate_world = _spine_bone_rotate_worldPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_world_to_local_rotation_x(spine_bone bone) {
    return _spine_bone_get_world_to_local_rotation_x(bone);
  }

  late final _spine_bone_get_world_to_local_rotation_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_world_to_local_rotation_x',
  );
  late final _spine_bone_get_world_to_local_rotation_x = _spine_bone_get_world_to_local_rotation_xPtr
      .asFunction<double Function(spine_bone)>();

  double spine_bone_get_world_to_local_rotation_y(spine_bone bone) {
    return _spine_bone_get_world_to_local_rotation_y(bone);
  }

  late final _spine_bone_get_world_to_local_rotation_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_world_to_local_rotation_y',
  );
  late final _spine_bone_get_world_to_local_rotation_y = _spine_bone_get_world_to_local_rotation_yPtr
      .asFunction<double Function(spine_bone)>();

  spine_bone_data spine_bone_get_data(spine_bone bone) {
    return _spine_bone_get_data(bone);
  }

  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_skeleton spine_bone_get_skeleton(spine_bone bone) {
    return _spine_bone_get_skeleton(bone);
  }

  late final _spine_bone_get_skeletonPtr = _lookup<ffi.NativeFunction<spine_skeleton Function(spine_bone)>>(
    'spine_bone_get_skeleton',
  );
  late final _spine_bone_get_skeleton = _spine_bone_get_skeletonPtr.asFunction<spine_skeleton Function(spine_bone)>();

  spine_bone spine_bone_get_parent(spine_bone bone) {
    return _spine_bone_get_parent(bone);
  }

  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)>();

  int spine_bone_get_num_children(spine_bone bone) {
    return _spine_bone_get_num_children(bone);
  }

  late final _spine_bone_get_num_childrenPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_bone)>>(
    'spine_bone_get_num_children',
  );
  late final _spine_bone_get_num_children = _spine_bone_get_num_childrenPtr.asFunction<int Function(spine_bone)>();

  ffi.Pointer<spine_bone> spine_bone_get_children(spine_bone bone) {
    return _spine_bone_get_children(bone);
  }

  late final _spine_bone_get_childrenPtr = _lookup<ffi.NativeFunction<ffi.Pointer<spine_bone> Function(spine_bone)>>(
    'spine_bone_get_children',
  );
  late final _spine_bone_get_children = _spine_bone_get_childrenPtr
      .asFunction<ffi.Pointer<spine_bone> Function(spine_bone)>();

  double spine_bone_get_x(spine_bone bone) {
    return _spine_bone_get_x(bone);
  }

  late final _spine_bone_get_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_x');
  late final _spine_bone_get_x = _spine_bone_get_xPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_x(spine_bone bone, double x) {
    return _spine_bone_set_x(bone, x);
  }

  late final _spine_bone_set_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_x',
  );
  late final _spine_bone_set_x = _spine_bone_set_xPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_y(spine_bone bone) {
    return _spine_bone_get_y(bone);
  }

  late final _spine_bone_get_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_y');
  late final _spine_bone_get_y = _spine_bone_get_yPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_y(spine_bone bone, double y) {
    return _spine_bone_set_y(bone, y);
  }

  late final _spine_bone_set_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_y',
  );
  late final _spine_bone_set_y = _spine_bone_set_yPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_rotation(spine_bone bone) {
    return _spine_bone_get_rotation(bone);
  }

  late final _spine_bone_get_rotationPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_rotation',
  );
  late final _spine_bone_get_rotation = _spine_bone_get_rotationPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_rotation(spine_bone bone, double rotation) {
    return _spine_bone_set_rotation(bone, rotation);
  }

  late final _spine_bone_set_rotationPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_rotation',
  );
  late final _spine_bone_set_rotation = _spine_bone_set_rotationPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_scale_x(spine_bone bone) {
    return _spine_bone_get_scale_x(bone);
  }

  late final _spine_bone_get_scale_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_scale_x',
  );
  late final _spine_bone_get_scale_x = _spine_bone_get_scale_xPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_scale_x(spine_bone bone, double scaleX) {
    return _spine_bone_set_scale_x(bone, scaleX);
  }

  late final _spine_bone_set_scale_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_scale_x',
  );
  late final _spine_bone_set_scale_x = _spine_bone_set_scale_xPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_scale_y(spine_bone bone) {
    return _spine_bone_get_scale_y(bone);
  }

  late final _spine_bone_get_scale_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_scale_y',
  );
  late final _spine_bone_get_scale_y = _spine_bone_get_scale_yPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_scale_y(spine_bone bone, double scaleY) {
    return _spine_bone_set_scale_y(bone, scaleY);
  }

  late final _spine_bone_set_scale_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_scale_y',
  );
  late final _spine_bone_set_scale_y = _spine_bone_set_scale_yPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_shear_x(spine_bone bone) {
    return _spine_bone_get_shear_x(bone);
  }

  late final _spine_bone_get_shear_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_shear_x',
  );
  late final _spine_bone_get_shear_x = _spine_bone_get_shear_xPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_shear_x(spine_bone bone, double shearX) {
    return _spine_bone_set_shear_x(bone, shearX);
  }

  late final _spine_bone_set_shear_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_shear_x',
  );
  late final _spine_bone_set_shear_x = _spine_bone_set_shear_xPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_shear_y(spine_bone bone) {
    return _spine_bone_get_shear_y(bone);
  }

  late final _spine_bone_get_shear_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_shear_y',
  );
  late final _spine_bone_get_shear_y = _spine_bone_get_shear_yPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_shear_y(spine_bone bone, double shearY) {
    return _spine_bone_set_shear_y(bone, shearY);
  }

  late final _spine_bone_set_shear_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_shear_y',
  );
  late final _spine_bone_set_shear_y = _spine_bone_set_shear_yPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_applied_rotation(spine_bone bone) {
    return _spine_bone_get_applied_rotation(bone);
  }

  late final _spine_bone_get_applied_rotationPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_applied_rotation',
  );
  late final _spine_bone_get_applied_rotation = _spine_bone_get_applied_rotationPtr
      .asFunction<double Function(spine_bone)>();

  void spine_bone_set_applied_rotation(spine_bone bone, double rotation) {
    return _spine_bone_set_applied_rotation(bone, rotation);
  }

  late final _spine_bone_set_applied_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>('spine_bone_set_applied_rotation');
  late final _spine_bone_set_applied_rotation = _spine_bone_set_applied_rotationPtr
      .asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_a_x(spine_bone bone) {
    return _spine_bone_get_a_x(bone);
  }

  late final _spine_bone_get_a_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_a_x');
  late final _spine_bone_get_a_x = _spine_bone_get_a_xPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_a_x(spine_bone bone, double x) {
    return _spine_bone_set_a_x(bone, x);
  }

  late final _spine_bone_set_a_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_a_x',
  );
  late final _spine_bone_set_a_x = _spine_bone_set_a_xPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_a_y(spine_bone bone) {
    return _spine_bone_get_a_y(bone);
  }

  late final _spine_bone_get_a_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_a_y');
  late final _spine_bone_get_a_y = _spine_bone_get_a_yPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_a_y(spine_bone bone, double y) {
    return _spine_bone_set_a_y(bone, y);
  }

  late final _spine_bone_set_a_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_a_y',
  );
  late final _spine_bone_set_a_y = _spine_bone_set_a_yPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_a_scale_x(spine_bone bone) {
    return _spine_bone_get_a_scale_x(bone);
  }

  late final _spine_bone_get_a_scale_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_a_scale_x',
  );
  late final _spine_bone_get_a_scale_x = _spine_bone_get_a_scale_xPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_a_scale_x(spine_bone bone, double scaleX) {
    return _spine_bone_set_a_scale_x(bone, scaleX);
  }

  late final _spine_bone_set_a_scale_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_a_scale_x',
  );
  late final _spine_bone_set_a_scale_x = _spine_bone_set_a_scale_xPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_a_scale_y(spine_bone bone) {
    return _spine_bone_get_a_scale_y(bone);
  }

  late final _spine_bone_get_a_scale_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_a_scale_y',
  );
  late final _spine_bone_get_a_scale_y = _spine_bone_get_a_scale_yPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_a_scale_y(spine_bone bone, double scaleY) {
    return _spine_bone_set_a_scale_y(bone, scaleY);
  }

  late final _spine_bone_set_a_scale_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_a_scale_y',
  );
  late final _spine_bone_set_a_scale_y = _spine_bone_set_a_scale_yPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_a_shear_x(spine_bone bone) {
    return _spine_bone_get_a_shear_x(bone);
  }

  late final _spine_bone_get_a_shear_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_a_shear_x',
  );
  late final _spine_bone_get_a_shear_x = _spine_bone_get_a_shear_xPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_a_shear_x(spine_bone bone, double shearX) {
    return _spine_bone_set_a_shear_x(bone, shearX);
  }

  late final _spine_bone_set_a_shear_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_a_shear_x',
  );
  late final _spine_bone_set_a_shear_x = _spine_bone_set_a_shear_xPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_a_shear_y(spine_bone bone) {
    return _spine_bone_get_a_shear_y(bone);
  }

  late final _spine_bone_get_a_shear_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_a_shear_y',
  );
  late final _spine_bone_get_a_shear_y = _spine_bone_get_a_shear_yPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_a_shear_y(spine_bone bone, double shearY) {
    return _spine_bone_set_a_shear_y(bone, shearY);
  }

  late final _spine_bone_set_a_shear_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_a_shear_y',
  );
  late final _spine_bone_set_a_shear_y = _spine_bone_set_a_shear_yPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_a(spine_bone bone) {
    return _spine_bone_get_a(bone);
  }

  late final _spine_bone_get_aPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_a');
  late final _spine_bone_get_a = _spine_bone_get_aPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_a(spine_bone bone, double a) {
    return _spine_bone_set_a(bone, a);
  }

  late final _spine_bone_set_aPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_a',
  );
  late final _spine_bone_set_a = _spine_bone_set_aPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_b(spine_bone bone) {
    return _spine_bone_get_b(bone);
  }

  late final _spine_bone_get_bPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_b');
  late final _spine_bone_get_b = _spine_bone_get_bPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_b(spine_bone bone, double b) {
    return _spine_bone_set_b(bone, b);
  }

  late final _spine_bone_set_bPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_b',
  );
  late final _spine_bone_set_b = _spine_bone_set_bPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_c(spine_bone bone) {
    return _spine_bone_get_c(bone);
  }

  late final _spine_bone_get_cPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_c');
  late final _spine_bone_get_c = _spine_bone_get_cPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_c(spine_bone bone, double c) {
    return _spine_bone_set_c(bone, c);
  }

  late final _spine_bone_set_cPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_c',
  );
  late final _spine_bone_set_c = _spine_bone_set_cPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_d(spine_bone bone) {
    return _spine_bone_get_d(bone);
  }

  late final _spine_bone_get_dPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_d');
  late final _spine_bone_get_d = _spine_bone_get_dPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_d(spine_bone bone, double d) {
    return _spine_bone_set_d(bone, d);
  }

  late final _spine_bone_set_dPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_d',
  );
  late final _spine_bone_set_d = _spine_bone_set_dPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_world_x(spine_bone bone) {
    return _spine_bone_get_world_x(bone);
  }

  late final _spine_bone_get_world_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_world_x',
  );
  late final _spine_bone_get_world_x = _spine_bone_get_world_xPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_world_x(spine_bone bone, double worldX) {
    return _spine_bone_set_world_x(bone, worldX);
  }

  late final _spine_bone_set_world_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_world_x',
  );
  late final _spine_bone_set_world_x = _spine_bone_set_world_xPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_world_y(spine_bone bone) {
    return _spine_bone_get_world_y(bone);
  }

  late final _spine_bone_get_world_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_world_y',
  );
  late final _spine_bone_get_world_y = _spine_bone_get_world_yPtr.asFunction<double Function(spine_bone)>();

  void spine_bone_set_world_y(spine_bone bone, double worldY) {
    return _spine_bone_set_world_y(bone, worldY);
  }

  late final _spine_bone_set_world_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
    'spine_bone_set_world_y',
  );
  late final _spine_bone_set_world_y = _spine_bone_set_world_yPtr.asFunction<void Function(spine_bone, double)>();

  double spine_bone_get_world_rotation_x(spine_bone bone) {
    return _spine_bone_get_world_rotation_x(bone);
  }

  late final _spine_bone_get_world_rotation_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_world_rotation_x',
  );
  late final _spine_bone_get_world_rotation_x = _spine_bone_get_world_rotation_xPtr
      .asFunction<double Function(spine_bone)>();

  double spine_bone_get_world_rotation_y(spine_bone bone) {
    return _spine_bone_get_world_rotation_y(bone);
  }

  late final _spine_bone_get_world_rotation_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_world_rotation_y',
  );
  late final _spine_bone_get_world_rotation_y = _spine_bone_get_world_rotation_yPtr
      .asFunction<double Function(spine_bone)>();

  double spine_bone_get_world_scale_x(spine_bone bone) {
    return _spine_bone_get_world_scale_x(bone);
  }

  late final _spine_bone_get_world_scale_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_world_scale_x',
  );
  late final _spine_bone_get_world_scale_x = _spine_bone_get_world_scale_xPtr.asFunction<double Function(spine_bone)>();

  double spine_bone_get_world_scale_y(spine_bone bone) {
    return _spine_bone_get_world_scale_y(bone);
  }

  late final _spine_bone_get_world_scale_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
    'spine_bone_get_world_scale_y',
  );
  late final _spine_bone_get_world_scale_y = _spine_bone_get_world_scale_yPtr.asFunction<double Function(spine_bone)>();

  int spine_bone_get_is_active(spine_bone bone) {
    return _spine_bone_get_is_active(bone);
  }

  late final _spine_bone_get_is_activePtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_bone)>>(
    'spine_bone_get_is_active',
  );
  late final _spine_bone_get_is_active = _spine_bone_get_is_activePtr.asFunction<int Function(spine_bone)>();

  void spine_bone_set_is_active(spine_bone bone, int isActive) {
    return _spine_bone_set_is_active(bone, isActive);
  }

  late final _spine_bone_set_is_activePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, spine_bool)>>(
    'spine_bone_set_is_active',
  );
  late final _spine_bone_set_is_active = _spine_bone_set_is_activePtr.asFunction<void Function(spine_bone, int)>();

  int spine_bone_get_inherit(spine_bone data) {
    return _spine_bone_get_inherit(data);
  }

  late final _spine_bone_get_inheritPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_bone)>>(
    'spine_bone_get_inherit',
  );
  late final _spine_bone_get_inherit = _spine_bone_get_inheritPtr.asFunction<int Function(spine_bone)>();

  void spine_bone_set_inherit(spine_bone data, int inherit) {
    return _spine_bone_set_inherit(data, inherit);
  }

  late final _spine_bone_set_inheritPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Int32)>>(
    'spine_bone_set_inherit',
  );
  late final _spine_bone_set_inherit = _spine_bone_set_inheritPtr.asFunction<void Function(spine_bone, int)>();

  ffi.Pointer<utf8> spine_attachment_get_name(spine_attachment attachment) {
    return _spine_attachment_get_name(attachment);
  }

  late final _spine_attachment_get_namePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_attachment)>>(
    'spine_attachment_get_name',
  );
  late final _spine_attachment_get_name = _spine_attachment_get_namePtr
      .asFunction<ffi.Pointer<utf8> Function(spine_attachment)>();

  int spine_attachment_get_type(spine_attachment attachment) {
    return _spine_attachment_get_type(attachment);
  }

  late final _spine_attachment_get_typePtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_attachment)>>(
    'spine_attachment_get_type',
  );
  late final _spine_attachment_get_type = _spine_attachment_get_typePtr.asFunction<int Function(spine_attachment)>();

  spine_attachment spine_attachment_copy(spine_attachment attachment) {
    return _spine_attachment_copy(attachment);
  }

  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)>();

  void spine_attachment_dispose(spine_attachment attachment) {
    return _spine_attachment_dispose(attachment);
  }

  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_vector spine_point_attachment_compute_world_position(spine_point_attachment attachment, spine_bone bone) {
    return _spine_point_attachment_compute_world_position(attachment, bone);
  }

  late final _spine_point_attachment_compute_world_positionPtr =
      _lookup<ffi.NativeFunction<spine_vector Function(spine_point_attachment, spine_bone)>>(
        'spine_point_attachment_compute_world_position',
      );
  late final _spine_point_attachment_compute_world_position = _spine_point_attachment_compute_world_positionPtr
      .asFunction<spine_vector Function(spine_point_attachment, spine_bone)>();

  double spine_point_attachment_compute_world_rotation(spine_point_attachment attachment, spine_bone bone) {
    return _spine_point_attachment_compute_world_rotation(attachment, bone);
  }

  late final _spine_point_attachment_compute_world_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_point_attachment, spine_bone)>>(
        '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)>();

  double spine_point_attachment_get_x(spine_point_attachment attachment) {
    return _spine_point_attachment_get_x(attachment);
  }

  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 attachment, double x) {
    return _spine_point_attachment_set_x(attachment, x);
  }

  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 attachment) {
    return _spine_point_attachment_get_y(attachment);
  }

  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 attachment, double y) {
    return _spine_point_attachment_set_y(attachment, y);
  }

  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 attachment) {
    return _spine_point_attachment_get_rotation(attachment);
  }

  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 attachment, double rotation) {
    return _spine_point_attachment_set_rotation(attachment, rotation);
  }

  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 attachment) {
    return _spine_point_attachment_get_color(attachment);
  }

  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_set_color(spine_point_attachment attachment, double r, double g, double b, double a) {
    return _spine_point_attachment_set_color(attachment, r, g, b, a);
  }

  late final _spine_point_attachment_set_colorPtr =
      _lookup<
        ffi.NativeFunction<ffi.Void Function(spine_point_attachment, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>
      >('spine_point_attachment_set_color');
  late final _spine_point_attachment_set_color = _spine_point_attachment_set_colorPtr
      .asFunction<void Function(spine_point_attachment, double, double, double, double)>();

  void spine_region_attachment_update_region(spine_region_attachment attachment) {
    return _spine_region_attachment_update_region(attachment);
  }

  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)>();

  void spine_region_attachment_compute_world_vertices(
    spine_region_attachment attachment,
    spine_slot slot,
    ffi.Pointer<ffi.Float> worldVertices,
  ) {
    return _spine_region_attachment_compute_world_vertices(attachment, slot, worldVertices);
  }

  late final _spine_region_attachment_compute_world_verticesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, spine_slot, ffi.Pointer<ffi.Float>)>>(
        'spine_region_attachment_compute_world_vertices',
      );
  late final _spine_region_attachment_compute_world_vertices = _spine_region_attachment_compute_world_verticesPtr
      .asFunction<void Function(spine_region_attachment, spine_slot, ffi.Pointer<ffi.Float>)>();

  double spine_region_attachment_get_x(spine_region_attachment attachment) {
    return _spine_region_attachment_get_x(attachment);
  }

  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 attachment, double x) {
    return _spine_region_attachment_set_x(attachment, x);
  }

  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 attachment) {
    return _spine_region_attachment_get_y(attachment);
  }

  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 attachment, double y) {
    return _spine_region_attachment_set_y(attachment, y);
  }

  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 attachment) {
    return _spine_region_attachment_get_rotation(attachment);
  }

  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 attachment, double rotation) {
    return _spine_region_attachment_set_rotation(attachment, rotation);
  }

  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 attachment) {
    return _spine_region_attachment_get_scale_x(attachment);
  }

  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 attachment, double scaleX) {
    return _spine_region_attachment_set_scale_x(attachment, scaleX);
  }

  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 attachment) {
    return _spine_region_attachment_get_scale_y(attachment);
  }

  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 attachment, double scaleY) {
    return _spine_region_attachment_set_scale_y(attachment, scaleY);
  }

  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 attachment) {
    return _spine_region_attachment_get_width(attachment);
  }

  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 attachment, double width) {
    return _spine_region_attachment_set_width(attachment, width);
  }

  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 attachment) {
    return _spine_region_attachment_get_height(attachment);
  }

  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 attachment, double height) {
    return _spine_region_attachment_set_height(attachment, height);
  }

  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 attachment) {
    return _spine_region_attachment_get_color(attachment);
  }

  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)>();

  void spine_region_attachment_set_color(spine_region_attachment attachment, double r, double g, double b, double a) {
    return _spine_region_attachment_set_color(attachment, r, g, b, a);
  }

  late final _spine_region_attachment_set_colorPtr =
      _lookup<
        ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>
      >('spine_region_attachment_set_color');
  late final _spine_region_attachment_set_color = _spine_region_attachment_set_colorPtr
      .asFunction<void Function(spine_region_attachment, double, double, double, double)>();

  ffi.Pointer<utf8> spine_region_attachment_get_path(spine_region_attachment attachment) {
    return _spine_region_attachment_get_path(attachment);
  }

  late final _spine_region_attachment_get_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_region_attachment)>>(
        'spine_region_attachment_get_path',
      );
  late final _spine_region_attachment_get_path = _spine_region_attachment_get_pathPtr
      .asFunction<ffi.Pointer<utf8> Function(spine_region_attachment)>();

  /// OMITTED setPath()
  spine_texture_region spine_region_attachment_get_region(spine_region_attachment attachment) {
    return _spine_region_attachment_get_region(attachment);
  }

  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)>();

  /// OMITTED setRegion()
  spine_sequence spine_region_attachment_get_sequence(spine_region_attachment attachment) {
    return _spine_region_attachment_get_sequence(attachment);
  }

  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)>();

  /// OMITTED setSequence()
  int spine_region_attachment_get_num_offset(spine_region_attachment attachment) {
    return _spine_region_attachment_get_num_offset(attachment);
  }

  late final _spine_region_attachment_get_num_offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_region_attachment)>>(
        'spine_region_attachment_get_num_offset',
      );
  late final _spine_region_attachment_get_num_offset = _spine_region_attachment_get_num_offsetPtr
      .asFunction<int Function(spine_region_attachment)>();

  ffi.Pointer<ffi.Float> spine_region_attachment_get_offset(spine_region_attachment attachment) {
    return _spine_region_attachment_get_offset(attachment);
  }

  late final _spine_region_attachment_get_offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_region_attachment)>>(
        'spine_region_attachment_get_offset',
      );
  late final _spine_region_attachment_get_offset = _spine_region_attachment_get_offsetPtr
      .asFunction<ffi.Pointer<ffi.Float> Function(spine_region_attachment)>();

  int spine_region_attachment_get_num_uvs(spine_region_attachment attachment) {
    return _spine_region_attachment_get_num_uvs(attachment);
  }

  late final _spine_region_attachment_get_num_uvsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_region_attachment)>>('spine_region_attachment_get_num_uvs');
  late final _spine_region_attachment_get_num_uvs = _spine_region_attachment_get_num_uvsPtr
      .asFunction<int Function(spine_region_attachment)>();

  ffi.Pointer<ffi.Float> spine_region_attachment_get_uvs(spine_region_attachment attachment) {
    return _spine_region_attachment_get_uvs(attachment);
  }

  late final _spine_region_attachment_get_uvsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_region_attachment)>>(
        'spine_region_attachment_get_uvs',
      );
  late final _spine_region_attachment_get_uvs = _spine_region_attachment_get_uvsPtr
      .asFunction<ffi.Pointer<ffi.Float> Function(spine_region_attachment)>();

  int spine_vertex_attachment_get_world_vertices_length(spine_vertex_attachment attachment) {
    return _spine_vertex_attachment_get_world_vertices_length(attachment);
  }

  late final _spine_vertex_attachment_get_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 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_compute_world_vertices(
    spine_vertex_attachment attachment,
    spine_slot slot,
    ffi.Pointer<ffi.Float> worldVertices,
  ) {
    return _spine_vertex_attachment_compute_world_vertices(attachment, slot, worldVertices);
  }

  late final _spine_vertex_attachment_compute_world_verticesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment, spine_slot, ffi.Pointer<ffi.Float>)>>(
        'spine_vertex_attachment_compute_world_vertices',
      );
  late final _spine_vertex_attachment_compute_world_vertices = _spine_vertex_attachment_compute_world_verticesPtr
      .asFunction<void Function(spine_vertex_attachment, spine_slot, ffi.Pointer<ffi.Float>)>();

  /// OMITTED getId()
  int spine_vertex_attachment_get_num_bones(spine_vertex_attachment attachment) {
    return _spine_vertex_attachment_get_num_bones(attachment);
  }

  late final _spine_vertex_attachment_get_num_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_vertex_attachment)>>('spine_vertex_attachment_get_num_bones');
  late final _spine_vertex_attachment_get_num_bones = _spine_vertex_attachment_get_num_bonesPtr
      .asFunction<int Function(spine_vertex_attachment)>();

  ffi.Pointer<ffi.Int32> spine_vertex_attachment_get_bones(spine_vertex_attachment attachment) {
    return _spine_vertex_attachment_get_bones(attachment);
  }

  late final _spine_vertex_attachment_get_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Int32> Function(spine_vertex_attachment)>>(
        'spine_vertex_attachment_get_bones',
      );
  late final _spine_vertex_attachment_get_bones = _spine_vertex_attachment_get_bonesPtr
      .asFunction<ffi.Pointer<ffi.Int32> Function(spine_vertex_attachment)>();

  int spine_vertex_attachment_get_num_vertices(spine_vertex_attachment attachment) {
    return _spine_vertex_attachment_get_num_vertices(attachment);
  }

  late final _spine_vertex_attachment_get_num_verticesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_vertex_attachment)>>(
        'spine_vertex_attachment_get_num_vertices',
      );
  late final _spine_vertex_attachment_get_num_vertices = _spine_vertex_attachment_get_num_verticesPtr
      .asFunction<int Function(spine_vertex_attachment)>();

  ffi.Pointer<ffi.Float> spine_vertex_attachment_get_vertices(spine_vertex_attachment attachment) {
    return _spine_vertex_attachment_get_vertices(attachment);
  }

  late final _spine_vertex_attachment_get_verticesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_vertex_attachment)>>(
        'spine_vertex_attachment_get_vertices',
      );
  late final _spine_vertex_attachment_get_vertices = _spine_vertex_attachment_get_verticesPtr
      .asFunction<ffi.Pointer<ffi.Float> Function(spine_vertex_attachment)>();

  spine_attachment spine_vertex_attachment_get_timeline_attachment(spine_vertex_attachment timelineAttachment) {
    return _spine_vertex_attachment_get_timeline_attachment(timelineAttachment);
  }

  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 attachment,
    spine_attachment timelineAttachment,
  ) {
    return _spine_vertex_attachment_set_timeline_attachment(attachment, timelineAttachment);
  }

  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)>();

  /// OMITTED copyTo()
  void spine_mesh_attachment_update_region(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_update_region(attachment);
  }

  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 attachment) {
    return _spine_mesh_attachment_get_hull_length(attachment);
  }

  late final _spine_mesh_attachment_get_hull_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 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 attachment, int hullLength) {
    return _spine_mesh_attachment_set_hull_length(attachment, hullLength);
  }

  late final _spine_mesh_attachment_set_hull_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Int32)>>(
        '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)>();

  int spine_mesh_attachment_get_num_region_uvs(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_num_region_uvs(attachment);
  }

  late final _spine_mesh_attachment_get_num_region_uvsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_mesh_attachment)>>(
        'spine_mesh_attachment_get_num_region_uvs',
      );
  late final _spine_mesh_attachment_get_num_region_uvs = _spine_mesh_attachment_get_num_region_uvsPtr
      .asFunction<int Function(spine_mesh_attachment)>();

  ffi.Pointer<ffi.Float> spine_mesh_attachment_get_region_uvs(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_region_uvs(attachment);
  }

  late final _spine_mesh_attachment_get_region_uvsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_mesh_attachment)>>(
        'spine_mesh_attachment_get_region_uvs',
      );
  late final _spine_mesh_attachment_get_region_uvs = _spine_mesh_attachment_get_region_uvsPtr
      .asFunction<ffi.Pointer<ffi.Float> Function(spine_mesh_attachment)>();

  int spine_mesh_attachment_get_num_uvs(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_num_uvs(attachment);
  }

  late final _spine_mesh_attachment_get_num_uvsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_num_uvs');
  late final _spine_mesh_attachment_get_num_uvs = _spine_mesh_attachment_get_num_uvsPtr
      .asFunction<int Function(spine_mesh_attachment)>();

  ffi.Pointer<ffi.Float> spine_mesh_attachment_get_uvs(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_uvs(attachment);
  }

  late final _spine_mesh_attachment_get_uvsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_mesh_attachment)>>(
        'spine_mesh_attachment_get_uvs',
      );
  late final _spine_mesh_attachment_get_uvs = _spine_mesh_attachment_get_uvsPtr
      .asFunction<ffi.Pointer<ffi.Float> Function(spine_mesh_attachment)>();

  int spine_mesh_attachment_get_num_triangles(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_num_triangles(attachment);
  }

  late final _spine_mesh_attachment_get_num_trianglesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_num_triangles');
  late final _spine_mesh_attachment_get_num_triangles = _spine_mesh_attachment_get_num_trianglesPtr
      .asFunction<int Function(spine_mesh_attachment)>();

  ffi.Pointer<ffi.Uint16> spine_mesh_attachment_get_triangles(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_triangles(attachment);
  }

  late final _spine_mesh_attachment_get_trianglesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Uint16> Function(spine_mesh_attachment)>>(
        'spine_mesh_attachment_get_triangles',
      );
  late final _spine_mesh_attachment_get_triangles = _spine_mesh_attachment_get_trianglesPtr
      .asFunction<ffi.Pointer<ffi.Uint16> Function(spine_mesh_attachment)>();

  spine_color spine_mesh_attachment_get_color(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_color(attachment);
  }

  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)>();

  void spine_mesh_attachment_set_color(spine_mesh_attachment attachment, double r, double g, double b, double a) {
    return _spine_mesh_attachment_set_color(attachment, r, g, b, a);
  }

  late final _spine_mesh_attachment_set_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
        'spine_mesh_attachment_set_color',
      );
  late final _spine_mesh_attachment_set_color = _spine_mesh_attachment_set_colorPtr
      .asFunction<void Function(spine_mesh_attachment, double, double, double, double)>();

  ffi.Pointer<utf8> spine_mesh_attachment_get_path(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_path(attachment);
  }

  late final _spine_mesh_attachment_get_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_path');
  late final _spine_mesh_attachment_get_path = _spine_mesh_attachment_get_pathPtr
      .asFunction<ffi.Pointer<utf8> Function(spine_mesh_attachment)>();

  /// OMITTED setPath()
  spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_region(attachment);
  }

  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)>();

  /// OMITTED setRegion()
  spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_sequence(attachment);
  }

  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)>();

  /// OMITTED setSequence()
  spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_parent_mesh(attachment);
  }

  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 attachment, spine_mesh_attachment parentMesh) {
    return _spine_mesh_attachment_set_parent_mesh(attachment, parentMesh);
  }

  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)>();

  int spine_mesh_attachment_get_num_edges(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_num_edges(attachment);
  }

  late final _spine_mesh_attachment_get_num_edgesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_num_edges');
  late final _spine_mesh_attachment_get_num_edges = _spine_mesh_attachment_get_num_edgesPtr
      .asFunction<int Function(spine_mesh_attachment)>();

  ffi.Pointer<ffi.Uint16> spine_mesh_attachment_get_edges(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_edges(attachment);
  }

  late final _spine_mesh_attachment_get_edgesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Uint16> Function(spine_mesh_attachment)>>(
        'spine_mesh_attachment_get_edges',
      );
  late final _spine_mesh_attachment_get_edges = _spine_mesh_attachment_get_edgesPtr
      .asFunction<ffi.Pointer<ffi.Uint16> Function(spine_mesh_attachment)>();

  double spine_mesh_attachment_get_width(spine_mesh_attachment attachment) {
    return _spine_mesh_attachment_get_width(attachment);
  }

  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 attachment, double width) {
    return _spine_mesh_attachment_set_width(attachment, width);
  }

  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 attachment) {
    return _spine_mesh_attachment_get_height(attachment);
  }

  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 attachment, double height) {
    return _spine_mesh_attachment_set_height(attachment, height);
  }

  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)>();

  /// OMITTED newLinkedMesh()
  spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment attachment) {
    return _spine_clipping_attachment_get_end_slot(attachment);
  }

  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 attachment, spine_slot_data endSlot) {
    return _spine_clipping_attachment_set_end_slot(attachment, endSlot);
  }

  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 attachment) {
    return _spine_clipping_attachment_get_color(attachment);
  }

  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)>();

  void spine_clipping_attachment_set_color(
    spine_clipping_attachment attachment,
    double r,
    double g,
    double b,
    double a,
  ) {
    return _spine_clipping_attachment_set_color(attachment, r, g, b, a);
  }

  late final _spine_clipping_attachment_set_colorPtr =
      _lookup<
        ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>
      >('spine_clipping_attachment_set_color');
  late final _spine_clipping_attachment_set_color = _spine_clipping_attachment_set_colorPtr
      .asFunction<void Function(spine_clipping_attachment, double, double, double, double)>();

  spine_color spine_bounding_box_attachment_get_color(spine_bounding_box_attachment attachment) {
    return _spine_bounding_box_attachment_get_color(attachment);
  }

  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)>();

  void spine_bounding_box_attachment_set_color(
    spine_bounding_box_attachment attachment,
    double r,
    double g,
    double b,
    double a,
  ) {
    return _spine_bounding_box_attachment_set_color(attachment, r, g, b, a);
  }

  late final _spine_bounding_box_attachment_set_colorPtr =
      _lookup<
        ffi.NativeFunction<ffi.Void Function(spine_bounding_box_attachment, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>
      >('spine_bounding_box_attachment_set_color');
  late final _spine_bounding_box_attachment_set_color = _spine_bounding_box_attachment_set_colorPtr
      .asFunction<void Function(spine_bounding_box_attachment, double, double, double, double)>();

  int spine_path_attachment_get_num_lengths(spine_path_attachment attachment) {
    return _spine_path_attachment_get_num_lengths(attachment);
  }

  late final _spine_path_attachment_get_num_lengthsPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_attachment)>>('spine_path_attachment_get_num_lengths');
  late final _spine_path_attachment_get_num_lengths = _spine_path_attachment_get_num_lengthsPtr
      .asFunction<int Function(spine_path_attachment)>();

  ffi.Pointer<ffi.Float> spine_path_attachment_get_lengths(spine_path_attachment attachment) {
    return _spine_path_attachment_get_lengths(attachment);
  }

  late final _spine_path_attachment_get_lengthsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_path_attachment)>>(
        'spine_path_attachment_get_lengths',
      );
  late final _spine_path_attachment_get_lengths = _spine_path_attachment_get_lengthsPtr
      .asFunction<ffi.Pointer<ffi.Float> Function(spine_path_attachment)>();

  int spine_path_attachment_get_is_closed(spine_path_attachment attachment) {
    return _spine_path_attachment_get_is_closed(attachment);
  }

  late final _spine_path_attachment_get_is_closedPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_path_attachment)>>('spine_path_attachment_get_is_closed');
  late final _spine_path_attachment_get_is_closed = _spine_path_attachment_get_is_closedPtr
      .asFunction<int Function(spine_path_attachment)>();

  void spine_path_attachment_set_is_closed(spine_path_attachment attachment, int isClosed) {
    return _spine_path_attachment_set_is_closed(attachment, isClosed);
  }

  late final _spine_path_attachment_set_is_closedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, spine_bool)>>(
        'spine_path_attachment_set_is_closed',
      );
  late final _spine_path_attachment_set_is_closed = _spine_path_attachment_set_is_closedPtr
      .asFunction<void Function(spine_path_attachment, int)>();

  int spine_path_attachment_get_is_constant_speed(spine_path_attachment attachment) {
    return _spine_path_attachment_get_is_constant_speed(attachment);
  }

  late final _spine_path_attachment_get_is_constant_speedPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_path_attachment)>>(
        'spine_path_attachment_get_is_constant_speed',
      );
  late final _spine_path_attachment_get_is_constant_speed = _spine_path_attachment_get_is_constant_speedPtr
      .asFunction<int Function(spine_path_attachment)>();

  void spine_path_attachment_set_is_constant_speed(spine_path_attachment attachment, int isConstantSpeed) {
    return _spine_path_attachment_set_is_constant_speed(attachment, isConstantSpeed);
  }

  late final _spine_path_attachment_set_is_constant_speedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, spine_bool)>>(
        'spine_path_attachment_set_is_constant_speed',
      );
  late final _spine_path_attachment_set_is_constant_speed = _spine_path_attachment_set_is_constant_speedPtr
      .asFunction<void Function(spine_path_attachment, int)>();

  spine_color spine_path_attachment_get_color(spine_path_attachment attachment) {
    return _spine_path_attachment_get_color(attachment);
  }

  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)>();

  void spine_path_attachment_set_color(spine_path_attachment attachment, double r, double g, double b, double a) {
    return _spine_path_attachment_set_color(attachment, r, g, b, a);
  }

  late final _spine_path_attachment_set_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
        'spine_path_attachment_set_color',
      );
  late final _spine_path_attachment_set_color = _spine_path_attachment_set_colorPtr
      .asFunction<void Function(spine_path_attachment, double, double, double, double)>();

  void spine_skin_set_attachment(spine_skin skin, int slotIndex, ffi.Pointer<utf8> name, spine_attachment attachment) {
    return _spine_skin_set_attachment(skin, slotIndex, name, attachment);
  }

  late final _spine_skin_set_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin, ffi.Int32, ffi.Pointer<utf8>, spine_attachment)>>(
        'spine_skin_set_attachment',
      );
  late final _spine_skin_set_attachment = _spine_skin_set_attachmentPtr
      .asFunction<void Function(spine_skin, int, ffi.Pointer<utf8>, spine_attachment)>();

  spine_attachment spine_skin_get_attachment(spine_skin skin, int slotIndex, ffi.Pointer<utf8> name) {
    return _spine_skin_get_attachment(skin, slotIndex, name);
  }

  late final _spine_skin_get_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_skin, ffi.Int32, ffi.Pointer<utf8>)>>(
        'spine_skin_get_attachment',
      );
  late final _spine_skin_get_attachment = _spine_skin_get_attachmentPtr
      .asFunction<spine_attachment Function(spine_skin, int, ffi.Pointer<utf8>)>();

  void spine_skin_remove_attachment(spine_skin skin, int slotIndex, ffi.Pointer<utf8> name) {
    return _spine_skin_remove_attachment(skin, slotIndex, name);
  }

  late final _spine_skin_remove_attachmentPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin, ffi.Int32, ffi.Pointer<utf8>)>>(
        'spine_skin_remove_attachment',
      );
  late final _spine_skin_remove_attachment = _spine_skin_remove_attachmentPtr
      .asFunction<void Function(spine_skin, int, ffi.Pointer<utf8>)>();

  /// OMITTED findNamesForSlot()
  /// OMITTED findAttachmentsForSlot()
  /// OMITTED getColor()
  ffi.Pointer<utf8> spine_skin_get_name(spine_skin skin) {
    return _spine_skin_get_name(skin);
  }

  late final _spine_skin_get_namePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_skin)>>(
    'spine_skin_get_name',
  );
  late final _spine_skin_get_name = _spine_skin_get_namePtr.asFunction<ffi.Pointer<utf8> Function(spine_skin)>();

  void spine_skin_add_skin(spine_skin skin, spine_skin other) {
    return _spine_skin_add_skin(skin, 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)>();

  void spine_skin_copy_skin(spine_skin skin, spine_skin other) {
    return _spine_skin_copy_skin(skin, 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_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)>();

  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)>();

  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_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<utf8> 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<utf8> Function(spine_skin_entry)>>(
    'spine_skin_entry_get_name',
  );
  late final _spine_skin_entry_get_name = _spine_skin_entry_get_namePtr
      .asFunction<ffi.Pointer<utf8> 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)>();

  int spine_skin_get_num_bones(spine_skin skin) {
    return _spine_skin_get_num_bones(skin);
  }

  late final _spine_skin_get_num_bonesPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skin)>>(
    'spine_skin_get_num_bones',
  );
  late final _spine_skin_get_num_bones = _spine_skin_get_num_bonesPtr.asFunction<int Function(spine_skin)>();

  ffi.Pointer<spine_bone_data> spine_skin_get_bones(spine_skin skin) {
    return _spine_skin_get_bones(skin);
  }

  late final _spine_skin_get_bonesPtr = _lookup<ffi.NativeFunction<ffi.Pointer<spine_bone_data> Function(spine_skin)>>(
    'spine_skin_get_bones',
  );
  late final _spine_skin_get_bones = _spine_skin_get_bonesPtr
      .asFunction<ffi.Pointer<spine_bone_data> Function(spine_skin)>();

  int spine_skin_get_num_constraints(spine_skin skin) {
    return _spine_skin_get_num_constraints(skin);
  }

  late final _spine_skin_get_num_constraintsPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skin)>>(
    'spine_skin_get_num_constraints',
  );
  late final _spine_skin_get_num_constraints = _spine_skin_get_num_constraintsPtr
      .asFunction<int Function(spine_skin)>();

  ffi.Pointer<spine_constraint_data> spine_skin_get_constraints(spine_skin skin) {
    return _spine_skin_get_constraints(skin);
  }

  late final _spine_skin_get_constraintsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_constraint_data> Function(spine_skin)>>(
        'spine_skin_get_constraints',
      );
  late final _spine_skin_get_constraints = _spine_skin_get_constraintsPtr
      .asFunction<ffi.Pointer<spine_constraint_data> Function(spine_skin)>();

  spine_skin spine_skin_create(ffi.Pointer<utf8> name) {
    return _spine_skin_create(name);
  }

  late final _spine_skin_createPtr = _lookup<ffi.NativeFunction<spine_skin Function(ffi.Pointer<utf8>)>>(
    'spine_skin_create',
  );
  late final _spine_skin_create = _spine_skin_createPtr.asFunction<spine_skin Function(ffi.Pointer<utf8>)>();

  void spine_skin_dispose(spine_skin skin) {
    return _spine_skin_dispose(skin);
  }

  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)>();

  int spine_constraint_data_get_type(spine_constraint_data data) {
    return _spine_constraint_data_get_type(data);
  }

  late final _spine_constraint_data_get_typePtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_constraint_data)>>('spine_constraint_data_get_type');
  late final _spine_constraint_data_get_type = _spine_constraint_data_get_typePtr
      .asFunction<int Function(spine_constraint_data)>();

  ffi.Pointer<utf8> spine_constraint_data_get_name(spine_constraint_data data) {
    return _spine_constraint_data_get_name(data);
  }

  late final _spine_constraint_data_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_constraint_data)>>('spine_constraint_data_get_name');
  late final _spine_constraint_data_get_name = _spine_constraint_data_get_namePtr
      .asFunction<ffi.Pointer<utf8> Function(spine_constraint_data)>();

  int spine_constraint_data_get_order(spine_constraint_data data) {
    return _spine_constraint_data_get_order(data);
  }

  late final _spine_constraint_data_get_orderPtr =
      _lookup<ffi.NativeFunction<ffi.Uint64 Function(spine_constraint_data)>>('spine_constraint_data_get_order');
  late final _spine_constraint_data_get_order = _spine_constraint_data_get_orderPtr
      .asFunction<int Function(spine_constraint_data)>();

  void spine_constraint_data_set_order(spine_constraint_data data, int order) {
    return _spine_constraint_data_set_order(data, order);
  }

  late final _spine_constraint_data_set_orderPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_data, ffi.Uint64)>>(
        'spine_constraint_data_set_order',
      );
  late final _spine_constraint_data_set_order = _spine_constraint_data_set_orderPtr
      .asFunction<void Function(spine_constraint_data, int)>();

  int spine_constraint_data_get_is_skin_required(spine_constraint_data data) {
    return _spine_constraint_data_get_is_skin_required(data);
  }

  late final _spine_constraint_data_get_is_skin_requiredPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_constraint_data)>>(
        'spine_constraint_data_get_is_skin_required',
      );
  late final _spine_constraint_data_get_is_skin_required = _spine_constraint_data_get_is_skin_requiredPtr
      .asFunction<int Function(spine_constraint_data)>();

  void spine_constraint_data_set_is_skin_required(spine_constraint_data data, int isSkinRequired) {
    return _spine_constraint_data_set_is_skin_required(data, isSkinRequired);
  }

  late final _spine_constraint_data_set_is_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_data, spine_bool)>>(
        'spine_constraint_data_set_is_skin_required',
      );
  late final _spine_constraint_data_set_is_skin_required = _spine_constraint_data_set_is_skin_requiredPtr
      .asFunction<void Function(spine_constraint_data, int)>();

  int spine_ik_constraint_data_get_num_bones(spine_ik_constraint_data data) {
    return _spine_ik_constraint_data_get_num_bones(data);
  }

  late final _spine_ik_constraint_data_get_num_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint_data)>>(
        'spine_ik_constraint_data_get_num_bones',
      );
  late final _spine_ik_constraint_data_get_num_bones = _spine_ik_constraint_data_get_num_bonesPtr
      .asFunction<int Function(spine_ik_constraint_data)>();

  ffi.Pointer<spine_bone_data> spine_ik_constraint_data_get_bones(spine_ik_constraint_data data) {
    return _spine_ik_constraint_data_get_bones(data);
  }

  late final _spine_ik_constraint_data_get_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_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<ffi.Pointer<spine_bone_data> Function(spine_ik_constraint_data)>();

  spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constraint_data data) {
    return _spine_ik_constraint_data_get_target(data);
  }

  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 data, spine_bone_data target) {
    return _spine_ik_constraint_data_set_target(data, target);
  }

  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)>();

  int spine_ik_constraint_data_get_bend_direction(spine_ik_constraint_data data) {
    return _spine_ik_constraint_data_get_bend_direction(data);
  }

  late final _spine_ik_constraint_data_get_bend_directionPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint_data)>>(
        'spine_ik_constraint_data_get_bend_direction',
      );
  late final _spine_ik_constraint_data_get_bend_direction = _spine_ik_constraint_data_get_bend_directionPtr
      .asFunction<int Function(spine_ik_constraint_data)>();

  void spine_ik_constraint_data_set_bend_direction(spine_ik_constraint_data data, int bendDirection) {
    return _spine_ik_constraint_data_set_bend_direction(data, bendDirection);
  }

  late final _spine_ik_constraint_data_set_bend_directionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, ffi.Int32)>>(
        'spine_ik_constraint_data_set_bend_direction',
      );
  late final _spine_ik_constraint_data_set_bend_direction = _spine_ik_constraint_data_set_bend_directionPtr
      .asFunction<void Function(spine_ik_constraint_data, int)>();

  int spine_ik_constraint_data_get_compress(spine_ik_constraint_data data) {
    return _spine_ik_constraint_data_get_compress(data);
  }

  late final _spine_ik_constraint_data_get_compressPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_ik_constraint_data)>>(
        'spine_ik_constraint_data_get_compress',
      );
  late final _spine_ik_constraint_data_get_compress = _spine_ik_constraint_data_get_compressPtr
      .asFunction<int Function(spine_ik_constraint_data)>();

  void spine_ik_constraint_data_set_compress(spine_ik_constraint_data data, int compress) {
    return _spine_ik_constraint_data_set_compress(data, compress);
  }

  late final _spine_ik_constraint_data_set_compressPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, spine_bool)>>(
        'spine_ik_constraint_data_set_compress',
      );
  late final _spine_ik_constraint_data_set_compress = _spine_ik_constraint_data_set_compressPtr
      .asFunction<void Function(spine_ik_constraint_data, int)>();

  int spine_ik_constraint_data_get_stretch(spine_ik_constraint_data data) {
    return _spine_ik_constraint_data_get_stretch(data);
  }

  late final _spine_ik_constraint_data_get_stretchPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_ik_constraint_data)>>(
        'spine_ik_constraint_data_get_stretch',
      );
  late final _spine_ik_constraint_data_get_stretch = _spine_ik_constraint_data_get_stretchPtr
      .asFunction<int Function(spine_ik_constraint_data)>();

  void spine_ik_constraint_data_set_stretch(spine_ik_constraint_data data, int stretch) {
    return _spine_ik_constraint_data_set_stretch(data, stretch);
  }

  late final _spine_ik_constraint_data_set_stretchPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, spine_bool)>>(
        'spine_ik_constraint_data_set_stretch',
      );
  late final _spine_ik_constraint_data_set_stretch = _spine_ik_constraint_data_set_stretchPtr
      .asFunction<void Function(spine_ik_constraint_data, int)>();

  int spine_ik_constraint_data_get_uniform(spine_ik_constraint_data data) {
    return _spine_ik_constraint_data_get_uniform(data);
  }

  late final _spine_ik_constraint_data_get_uniformPtr =
      _lookup<ffi.NativeFunction<spine_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<int Function(spine_ik_constraint_data)>();

  void spine_ik_constraint_data_set_uniform(spine_ik_constraint_data data, int uniform) {
    return _spine_ik_constraint_data_set_uniform(data, uniform);
  }

  late final _spine_ik_constraint_data_set_uniformPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, spine_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, int)>();

  double spine_ik_constraint_data_get_mix(spine_ik_constraint_data data) {
    return _spine_ik_constraint_data_get_mix(data);
  }

  late final _spine_ik_constraint_data_get_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint_data)>>('spine_ik_constraint_data_get_mix');
  late final _spine_ik_constraint_data_get_mix = _spine_ik_constraint_data_get_mixPtr
      .asFunction<double Function(spine_ik_constraint_data)>();

  void spine_ik_constraint_data_set_mix(spine_ik_constraint_data data, double mix) {
    return _spine_ik_constraint_data_set_mix(data, mix);
  }

  late final _spine_ik_constraint_data_set_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, ffi.Float)>>(
        'spine_ik_constraint_data_set_mix',
      );
  late final _spine_ik_constraint_data_set_mix = _spine_ik_constraint_data_set_mixPtr
      .asFunction<void Function(spine_ik_constraint_data, double)>();

  double spine_ik_constraint_data_get_softness(spine_ik_constraint_data data) {
    return _spine_ik_constraint_data_get_softness(data);
  }

  late final _spine_ik_constraint_data_get_softnessPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint_data)>>(
        'spine_ik_constraint_data_get_softness',
      );
  late final _spine_ik_constraint_data_get_softness = _spine_ik_constraint_data_get_softnessPtr
      .asFunction<double Function(spine_ik_constraint_data)>();

  void spine_ik_constraint_data_set_softness(spine_ik_constraint_data data, double softness) {
    return _spine_ik_constraint_data_set_softness(data, softness);
  }

  late final _spine_ik_constraint_data_set_softnessPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, ffi.Float)>>(
        'spine_ik_constraint_data_set_softness',
      );
  late final _spine_ik_constraint_data_set_softness = _spine_ik_constraint_data_set_softnessPtr
      .asFunction<void Function(spine_ik_constraint_data, double)>();

  void spine_ik_constraint_update(spine_ik_constraint constraint) {
    return _spine_ik_constraint_update(constraint);
  }

  late final _spine_ik_constraint_updatePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint)>>(
    'spine_ik_constraint_update',
  );
  late final _spine_ik_constraint_update = _spine_ik_constraint_updatePtr
      .asFunction<void Function(spine_ik_constraint)>();

  int spine_ik_constraint_get_order(spine_ik_constraint constraint) {
    return _spine_ik_constraint_get_order(constraint);
  }

  late final _spine_ik_constraint_get_orderPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint)>>(
    'spine_ik_constraint_get_order',
  );
  late final _spine_ik_constraint_get_order = _spine_ik_constraint_get_orderPtr
      .asFunction<int Function(spine_ik_constraint)>();

  spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint constraint) {
    return _spine_ik_constraint_get_data(constraint);
  }

  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)>();

  int spine_ik_constraint_get_num_bones(spine_ik_constraint constraint) {
    return _spine_ik_constraint_get_num_bones(constraint);
  }

  late final _spine_ik_constraint_get_num_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint)>>('spine_ik_constraint_get_num_bones');
  late final _spine_ik_constraint_get_num_bones = _spine_ik_constraint_get_num_bonesPtr
      .asFunction<int Function(spine_ik_constraint)>();

  ffi.Pointer<spine_bone> spine_ik_constraint_get_bones(spine_ik_constraint constraint) {
    return _spine_ik_constraint_get_bones(constraint);
  }

  late final _spine_ik_constraint_get_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_bone> Function(spine_ik_constraint)>>(
        'spine_ik_constraint_get_bones',
      );
  late final _spine_ik_constraint_get_bones = _spine_ik_constraint_get_bonesPtr
      .asFunction<ffi.Pointer<spine_bone> Function(spine_ik_constraint)>();

  spine_bone spine_ik_constraint_get_target(spine_ik_constraint constraint) {
    return _spine_ik_constraint_get_target(constraint);
  }

  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 constraint, spine_bone target) {
    return _spine_ik_constraint_set_target(constraint, target);
  }

  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)>();

  int spine_ik_constraint_get_bend_direction(spine_ik_constraint constraint) {
    return _spine_ik_constraint_get_bend_direction(constraint);
  }

  late final _spine_ik_constraint_get_bend_directionPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint)>>('spine_ik_constraint_get_bend_direction');
  late final _spine_ik_constraint_get_bend_direction = _spine_ik_constraint_get_bend_directionPtr
      .asFunction<int Function(spine_ik_constraint)>();

  void spine_ik_constraint_set_bend_direction(spine_ik_constraint constraint, int bendDirection) {
    return _spine_ik_constraint_set_bend_direction(constraint, bendDirection);
  }

  late final _spine_ik_constraint_set_bend_directionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, ffi.Int32)>>(
        'spine_ik_constraint_set_bend_direction',
      );
  late final _spine_ik_constraint_set_bend_direction = _spine_ik_constraint_set_bend_directionPtr
      .asFunction<void Function(spine_ik_constraint, int)>();

  int spine_ik_constraint_get_compress(spine_ik_constraint constraint) {
    return _spine_ik_constraint_get_compress(constraint);
  }

  late final _spine_ik_constraint_get_compressPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_ik_constraint)>>('spine_ik_constraint_get_compress');
  late final _spine_ik_constraint_get_compress = _spine_ik_constraint_get_compressPtr
      .asFunction<int Function(spine_ik_constraint)>();

  void spine_ik_constraint_set_compress(spine_ik_constraint constraint, int compress) {
    return _spine_ik_constraint_set_compress(constraint, compress);
  }

  late final _spine_ik_constraint_set_compressPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, spine_bool)>>(
        'spine_ik_constraint_set_compress',
      );
  late final _spine_ik_constraint_set_compress = _spine_ik_constraint_set_compressPtr
      .asFunction<void Function(spine_ik_constraint, int)>();

  int spine_ik_constraint_get_stretch(spine_ik_constraint constraint) {
    return _spine_ik_constraint_get_stretch(constraint);
  }

  late final _spine_ik_constraint_get_stretchPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_ik_constraint)>>('spine_ik_constraint_get_stretch');
  late final _spine_ik_constraint_get_stretch = _spine_ik_constraint_get_stretchPtr
      .asFunction<int Function(spine_ik_constraint)>();

  void spine_ik_constraint_set_stretch(spine_ik_constraint constraint, int stretch) {
    return _spine_ik_constraint_set_stretch(constraint, stretch);
  }

  late final _spine_ik_constraint_set_stretchPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, spine_bool)>>(
        'spine_ik_constraint_set_stretch',
      );
  late final _spine_ik_constraint_set_stretch = _spine_ik_constraint_set_stretchPtr
      .asFunction<void Function(spine_ik_constraint, int)>();

  double spine_ik_constraint_get_mix(spine_ik_constraint constraint) {
    return _spine_ik_constraint_get_mix(constraint);
  }

  late final _spine_ik_constraint_get_mixPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint)>>(
    'spine_ik_constraint_get_mix',
  );
  late final _spine_ik_constraint_get_mix = _spine_ik_constraint_get_mixPtr
      .asFunction<double Function(spine_ik_constraint)>();

  void spine_ik_constraint_set_mix(spine_ik_constraint constraint, double mix) {
    return _spine_ik_constraint_set_mix(constraint, mix);
  }

  late final _spine_ik_constraint_set_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, ffi.Float)>>('spine_ik_constraint_set_mix');
  late final _spine_ik_constraint_set_mix = _spine_ik_constraint_set_mixPtr
      .asFunction<void Function(spine_ik_constraint, double)>();

  double spine_ik_constraint_get_softness(spine_ik_constraint constraint) {
    return _spine_ik_constraint_get_softness(constraint);
  }

  late final _spine_ik_constraint_get_softnessPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint)>>('spine_ik_constraint_get_softness');
  late final _spine_ik_constraint_get_softness = _spine_ik_constraint_get_softnessPtr
      .asFunction<double Function(spine_ik_constraint)>();

  void spine_ik_constraint_set_softness(spine_ik_constraint constraint, double softness) {
    return _spine_ik_constraint_set_softness(constraint, softness);
  }

  late final _spine_ik_constraint_set_softnessPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, ffi.Float)>>(
        'spine_ik_constraint_set_softness',
      );
  late final _spine_ik_constraint_set_softness = _spine_ik_constraint_set_softnessPtr
      .asFunction<void Function(spine_ik_constraint, double)>();

  int spine_ik_constraint_get_is_active(spine_ik_constraint constraint) {
    return _spine_ik_constraint_get_is_active(constraint);
  }

  late final _spine_ik_constraint_get_is_activePtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_ik_constraint)>>('spine_ik_constraint_get_is_active');
  late final _spine_ik_constraint_get_is_active = _spine_ik_constraint_get_is_activePtr
      .asFunction<int Function(spine_ik_constraint)>();

  void spine_ik_constraint_set_is_active(spine_ik_constraint constraint, int isActive) {
    return _spine_ik_constraint_set_is_active(constraint, isActive);
  }

  late final _spine_ik_constraint_set_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, spine_bool)>>(
        'spine_ik_constraint_set_is_active',
      );
  late final _spine_ik_constraint_set_is_active = _spine_ik_constraint_set_is_activePtr
      .asFunction<void Function(spine_ik_constraint, int)>();

  /// OMITTED setToSetupPose()
  int spine_transform_constraint_data_get_num_bones(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_num_bones(data);
  }

  late final _spine_transform_constraint_data_get_num_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_transform_constraint_data)>>(
        'spine_transform_constraint_data_get_num_bones',
      );
  late final _spine_transform_constraint_data_get_num_bones = _spine_transform_constraint_data_get_num_bonesPtr
      .asFunction<int Function(spine_transform_constraint_data)>();

  ffi.Pointer<spine_bone_data> spine_transform_constraint_data_get_bones(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_bones(data);
  }

  late final _spine_transform_constraint_data_get_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_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<ffi.Pointer<spine_bone_data> Function(spine_transform_constraint_data)>();

  spine_bone_data spine_transform_constraint_data_get_target(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_target(data);
  }

  late final _spine_transform_constraint_data_get_targetPtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_transform_constraint_data)>>(
        'spine_transform_constraint_data_get_target',
      );
  late final _spine_transform_constraint_data_get_target = _spine_transform_constraint_data_get_targetPtr
      .asFunction<spine_bone_data Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_target(spine_transform_constraint_data data, spine_bone_data target) {
    return _spine_transform_constraint_data_set_target(data, target);
  }

  late final _spine_transform_constraint_data_set_targetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, spine_bone_data)>>(
        'spine_transform_constraint_data_set_target',
      );
  late final _spine_transform_constraint_data_set_target = _spine_transform_constraint_data_set_targetPtr
      .asFunction<void Function(spine_transform_constraint_data, spine_bone_data)>();

  double spine_transform_constraint_data_get_mix_rotate(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_mix_rotate(data);
  }

  late final _spine_transform_constraint_data_get_mix_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
        'spine_transform_constraint_data_get_mix_rotate',
      );
  late final _spine_transform_constraint_data_get_mix_rotate = _spine_transform_constraint_data_get_mix_rotatePtr
      .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_mix_rotate(spine_transform_constraint_data data, double mixRotate) {
    return _spine_transform_constraint_data_set_mix_rotate(data, mixRotate);
  }

  late final _spine_transform_constraint_data_set_mix_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
        'spine_transform_constraint_data_set_mix_rotate',
      );
  late final _spine_transform_constraint_data_set_mix_rotate = _spine_transform_constraint_data_set_mix_rotatePtr
      .asFunction<void Function(spine_transform_constraint_data, double)>();

  double spine_transform_constraint_data_get_mix_x(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_mix_x(data);
  }

  late final _spine_transform_constraint_data_get_mix_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
        'spine_transform_constraint_data_get_mix_x',
      );
  late final _spine_transform_constraint_data_get_mix_x = _spine_transform_constraint_data_get_mix_xPtr
      .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_mix_x(spine_transform_constraint_data data, double mixX) {
    return _spine_transform_constraint_data_set_mix_x(data, mixX);
  }

  late final _spine_transform_constraint_data_set_mix_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
        'spine_transform_constraint_data_set_mix_x',
      );
  late final _spine_transform_constraint_data_set_mix_x = _spine_transform_constraint_data_set_mix_xPtr
      .asFunction<void Function(spine_transform_constraint_data, double)>();

  double spine_transform_constraint_data_get_mix_y(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_mix_y(data);
  }

  late final _spine_transform_constraint_data_get_mix_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
        'spine_transform_constraint_data_get_mix_y',
      );
  late final _spine_transform_constraint_data_get_mix_y = _spine_transform_constraint_data_get_mix_yPtr
      .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_mix_y(spine_transform_constraint_data data, double mixY) {
    return _spine_transform_constraint_data_set_mix_y(data, mixY);
  }

  late final _spine_transform_constraint_data_set_mix_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
        'spine_transform_constraint_data_set_mix_y',
      );
  late final _spine_transform_constraint_data_set_mix_y = _spine_transform_constraint_data_set_mix_yPtr
      .asFunction<void Function(spine_transform_constraint_data, double)>();

  double spine_transform_constraint_data_get_mix_scale_x(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_mix_scale_x(data);
  }

  late final _spine_transform_constraint_data_get_mix_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
        'spine_transform_constraint_data_get_mix_scale_x',
      );
  late final _spine_transform_constraint_data_get_mix_scale_x = _spine_transform_constraint_data_get_mix_scale_xPtr
      .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_mix_scale_x(spine_transform_constraint_data data, double mixScaleX) {
    return _spine_transform_constraint_data_set_mix_scale_x(data, mixScaleX);
  }

  late final _spine_transform_constraint_data_set_mix_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
        'spine_transform_constraint_data_set_mix_scale_x',
      );
  late final _spine_transform_constraint_data_set_mix_scale_x = _spine_transform_constraint_data_set_mix_scale_xPtr
      .asFunction<void Function(spine_transform_constraint_data, double)>();

  double spine_transform_constraint_data_get_mix_scale_y(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_mix_scale_y(data);
  }

  late final _spine_transform_constraint_data_get_mix_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
        'spine_transform_constraint_data_get_mix_scale_y',
      );
  late final _spine_transform_constraint_data_get_mix_scale_y = _spine_transform_constraint_data_get_mix_scale_yPtr
      .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_mix_scale_y(spine_transform_constraint_data data, double mixScaleY) {
    return _spine_transform_constraint_data_set_mix_scale_y(data, mixScaleY);
  }

  late final _spine_transform_constraint_data_set_mix_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
        'spine_transform_constraint_data_set_mix_scale_y',
      );
  late final _spine_transform_constraint_data_set_mix_scale_y = _spine_transform_constraint_data_set_mix_scale_yPtr
      .asFunction<void Function(spine_transform_constraint_data, double)>();

  double spine_transform_constraint_data_get_mix_shear_y(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_mix_shear_y(data);
  }

  late final _spine_transform_constraint_data_get_mix_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
        'spine_transform_constraint_data_get_mix_shear_y',
      );
  late final _spine_transform_constraint_data_get_mix_shear_y = _spine_transform_constraint_data_get_mix_shear_yPtr
      .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_mix_shear_y(spine_transform_constraint_data data, double mixShearY) {
    return _spine_transform_constraint_data_set_mix_shear_y(data, mixShearY);
  }

  late final _spine_transform_constraint_data_set_mix_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
        'spine_transform_constraint_data_set_mix_shear_y',
      );
  late final _spine_transform_constraint_data_set_mix_shear_y = _spine_transform_constraint_data_set_mix_shear_yPtr
      .asFunction<void Function(spine_transform_constraint_data, double)>();

  double spine_transform_constraint_data_get_offset_rotation(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_offset_rotation(data);
  }

  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 data,
    double offsetRotation,
  ) {
    return _spine_transform_constraint_data_set_offset_rotation(data, 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)>();

  double spine_transform_constraint_data_get_offset_x(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_offset_x(data);
  }

  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 data, double offsetX) {
    return _spine_transform_constraint_data_set_offset_x(data, 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)>();

  double spine_transform_constraint_data_get_offset_y(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_offset_y(data);
  }

  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 data, double offsetY) {
    return _spine_transform_constraint_data_set_offset_y(data, 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)>();

  double spine_transform_constraint_data_get_offset_scale_x(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_offset_scale_x(data);
  }

  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 data, double offsetScaleX) {
    return _spine_transform_constraint_data_set_offset_scale_x(data, 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)>();

  double spine_transform_constraint_data_get_offset_scale_y(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_offset_scale_y(data);
  }

  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 data, double offsetScaleY) {
    return _spine_transform_constraint_data_set_offset_scale_y(data, 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)>();

  double spine_transform_constraint_data_get_offset_shear_y(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_offset_shear_y(data);
  }

  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 data, double offsetShearY) {
    return _spine_transform_constraint_data_set_offset_shear_y(data, 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)>();

  int spine_transform_constraint_data_get_is_relative(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_is_relative(data);
  }

  late final _spine_transform_constraint_data_get_is_relativePtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_transform_constraint_data)>>(
        'spine_transform_constraint_data_get_is_relative',
      );
  late final _spine_transform_constraint_data_get_is_relative = _spine_transform_constraint_data_get_is_relativePtr
      .asFunction<int Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_is_relative(spine_transform_constraint_data data, int isRelative) {
    return _spine_transform_constraint_data_set_is_relative(data, isRelative);
  }

  late final _spine_transform_constraint_data_set_is_relativePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, spine_bool)>>(
        'spine_transform_constraint_data_set_is_relative',
      );
  late final _spine_transform_constraint_data_set_is_relative = _spine_transform_constraint_data_set_is_relativePtr
      .asFunction<void Function(spine_transform_constraint_data, int)>();

  int spine_transform_constraint_data_get_is_local(spine_transform_constraint_data data) {
    return _spine_transform_constraint_data_get_is_local(data);
  }

  late final _spine_transform_constraint_data_get_is_localPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_transform_constraint_data)>>(
        'spine_transform_constraint_data_get_is_local',
      );
  late final _spine_transform_constraint_data_get_is_local = _spine_transform_constraint_data_get_is_localPtr
      .asFunction<int Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_is_local(spine_transform_constraint_data data, int isLocal) {
    return _spine_transform_constraint_data_set_is_local(data, isLocal);
  }

  late final _spine_transform_constraint_data_set_is_localPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, spine_bool)>>(
        'spine_transform_constraint_data_set_is_local',
      );
  late final _spine_transform_constraint_data_set_is_local = _spine_transform_constraint_data_set_is_localPtr
      .asFunction<void Function(spine_transform_constraint_data, int)>();

  void spine_transform_constraint_update(spine_transform_constraint constraint) {
    return _spine_transform_constraint_update(constraint);
  }

  late final _spine_transform_constraint_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint)>>('spine_transform_constraint_update');
  late final _spine_transform_constraint_update = _spine_transform_constraint_updatePtr
      .asFunction<void Function(spine_transform_constraint)>();

  int spine_transform_constraint_get_order(spine_transform_constraint constraint) {
    return _spine_transform_constraint_get_order(constraint);
  }

  late final _spine_transform_constraint_get_orderPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_transform_constraint)>>(
        'spine_transform_constraint_get_order',
      );
  late final _spine_transform_constraint_get_order = _spine_transform_constraint_get_orderPtr
      .asFunction<int Function(spine_transform_constraint)>();

  spine_transform_constraint_data spine_transform_constraint_get_data(spine_transform_constraint constraint) {
    return _spine_transform_constraint_get_data(constraint);
  }

  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)>();

  int spine_transform_constraint_get_num_bones(spine_transform_constraint constraint) {
    return _spine_transform_constraint_get_num_bones(constraint);
  }

  late final _spine_transform_constraint_get_num_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_transform_constraint)>>(
        'spine_transform_constraint_get_num_bones',
      );
  late final _spine_transform_constraint_get_num_bones = _spine_transform_constraint_get_num_bonesPtr
      .asFunction<int Function(spine_transform_constraint)>();

  ffi.Pointer<spine_bone> spine_transform_constraint_get_bones(spine_transform_constraint constraint) {
    return _spine_transform_constraint_get_bones(constraint);
  }

  late final _spine_transform_constraint_get_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_bone> Function(spine_transform_constraint)>>(
        'spine_transform_constraint_get_bones',
      );
  late final _spine_transform_constraint_get_bones = _spine_transform_constraint_get_bonesPtr
      .asFunction<ffi.Pointer<spine_bone> Function(spine_transform_constraint)>();

  spine_bone spine_transform_constraint_get_target(spine_transform_constraint constraint) {
    return _spine_transform_constraint_get_target(constraint);
  }

  late final _spine_transform_constraint_get_targetPtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_transform_constraint)>>(
        'spine_transform_constraint_get_target',
      );
  late final _spine_transform_constraint_get_target = _spine_transform_constraint_get_targetPtr
      .asFunction<spine_bone Function(spine_transform_constraint)>();

  void spine_transform_constraint_set_target(spine_transform_constraint constraint, spine_bone target) {
    return _spine_transform_constraint_set_target(constraint, target);
  }

  late final _spine_transform_constraint_set_targetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, spine_bone)>>(
        'spine_transform_constraint_set_target',
      );
  late final _spine_transform_constraint_set_target = _spine_transform_constraint_set_targetPtr
      .asFunction<void Function(spine_transform_constraint, spine_bone)>();

  double spine_transform_constraint_get_mix_rotate(spine_transform_constraint constraint) {
    return _spine_transform_constraint_get_mix_rotate(constraint);
  }

  late final _spine_transform_constraint_get_mix_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
        'spine_transform_constraint_get_mix_rotate',
      );
  late final _spine_transform_constraint_get_mix_rotate = _spine_transform_constraint_get_mix_rotatePtr
      .asFunction<double Function(spine_transform_constraint)>();

  void spine_transform_constraint_set_mix_rotate(spine_transform_constraint constraint, double mixRotate) {
    return _spine_transform_constraint_set_mix_rotate(constraint, mixRotate);
  }

  late final _spine_transform_constraint_set_mix_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, ffi.Float)>>(
        'spine_transform_constraint_set_mix_rotate',
      );
  late final _spine_transform_constraint_set_mix_rotate = _spine_transform_constraint_set_mix_rotatePtr
      .asFunction<void Function(spine_transform_constraint, double)>();

  double spine_transform_constraint_get_mix_x(spine_transform_constraint constraint) {
    return _spine_transform_constraint_get_mix_x(constraint);
  }

  late final _spine_transform_constraint_get_mix_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
        'spine_transform_constraint_get_mix_x',
      );
  late final _spine_transform_constraint_get_mix_x = _spine_transform_constraint_get_mix_xPtr
      .asFunction<double Function(spine_transform_constraint)>();

  void spine_transform_constraint_set_mix_x(spine_transform_constraint constraint, double mixX) {
    return _spine_transform_constraint_set_mix_x(constraint, mixX);
  }

  late final _spine_transform_constraint_set_mix_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, ffi.Float)>>(
        'spine_transform_constraint_set_mix_x',
      );
  late final _spine_transform_constraint_set_mix_x = _spine_transform_constraint_set_mix_xPtr
      .asFunction<void Function(spine_transform_constraint, double)>();

  double spine_transform_constraint_get_mix_y(spine_transform_constraint constraint) {
    return _spine_transform_constraint_get_mix_y(constraint);
  }

  late final _spine_transform_constraint_get_mix_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
        'spine_transform_constraint_get_mix_y',
      );
  late final _spine_transform_constraint_get_mix_y = _spine_transform_constraint_get_mix_yPtr
      .asFunction<double Function(spine_transform_constraint)>();

  void spine_transform_constraint_set_mix_y(spine_transform_constraint constraint, double mixY) {
    return _spine_transform_constraint_set_mix_y(constraint, mixY);
  }

  late final _spine_transform_constraint_set_mix_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, ffi.Float)>>(
        'spine_transform_constraint_set_mix_y',
      );
  late final _spine_transform_constraint_set_mix_y = _spine_transform_constraint_set_mix_yPtr
      .asFunction<void Function(spine_transform_constraint, double)>();

  double spine_transform_constraint_get_mix_scale_x(spine_transform_constraint constraint) {
    return _spine_transform_constraint_get_mix_scale_x(constraint);
  }

  late final _spine_transform_constraint_get_mix_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
        'spine_transform_constraint_get_mix_scale_x',
      );
  late final _spine_transform_constraint_get_mix_scale_x = _spine_transform_constraint_get_mix_scale_xPtr
      .asFunction<double Function(spine_transform_constraint)>();

  void spine_transform_constraint_set_mix_scale_x(spine_transform_constraint constraint, double mixScaleX) {
    return _spine_transform_constraint_set_mix_scale_x(constraint, mixScaleX);
  }

  late final _spine_transform_constraint_set_mix_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, ffi.Float)>>(
        'spine_transform_constraint_set_mix_scale_x',
      );
  late final _spine_transform_constraint_set_mix_scale_x = _spine_transform_constraint_set_mix_scale_xPtr
      .asFunction<void Function(spine_transform_constraint, double)>();

  double spine_transform_constraint_get_mix_scale_y(spine_transform_constraint constraint) {
    return _spine_transform_constraint_get_mix_scale_y(constraint);
  }

  late final _spine_transform_constraint_get_mix_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
        'spine_transform_constraint_get_mix_scale_y',
      );
  late final _spine_transform_constraint_get_mix_scale_y = _spine_transform_constraint_get_mix_scale_yPtr
      .asFunction<double Function(spine_transform_constraint)>();

  void spine_transform_constraint_set_mix_scale_y(spine_transform_constraint constraint, double mixScaleY) {
    return _spine_transform_constraint_set_mix_scale_y(constraint, mixScaleY);
  }

  late final _spine_transform_constraint_set_mix_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, ffi.Float)>>(
        'spine_transform_constraint_set_mix_scale_y',
      );
  late final _spine_transform_constraint_set_mix_scale_y = _spine_transform_constraint_set_mix_scale_yPtr
      .asFunction<void Function(spine_transform_constraint, double)>();

  double spine_transform_constraint_get_mix_shear_y(spine_transform_constraint constraint) {
    return _spine_transform_constraint_get_mix_shear_y(constraint);
  }

  late final _spine_transform_constraint_get_mix_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
        'spine_transform_constraint_get_mix_shear_y',
      );
  late final _spine_transform_constraint_get_mix_shear_y = _spine_transform_constraint_get_mix_shear_yPtr
      .asFunction<double Function(spine_transform_constraint)>();

  void spine_transform_constraint_set_mix_shear_y(spine_transform_constraint constraint, double mixShearY) {
    return _spine_transform_constraint_set_mix_shear_y(constraint, mixShearY);
  }

  late final _spine_transform_constraint_set_mix_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, ffi.Float)>>(
        'spine_transform_constraint_set_mix_shear_y',
      );
  late final _spine_transform_constraint_set_mix_shear_y = _spine_transform_constraint_set_mix_shear_yPtr
      .asFunction<void Function(spine_transform_constraint, double)>();

  int spine_transform_constraint_get_is_active(spine_transform_constraint constraint) {
    return _spine_transform_constraint_get_is_active(constraint);
  }

  late final _spine_transform_constraint_get_is_activePtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_transform_constraint)>>(
        'spine_transform_constraint_get_is_active',
      );
  late final _spine_transform_constraint_get_is_active = _spine_transform_constraint_get_is_activePtr
      .asFunction<int Function(spine_transform_constraint)>();

  void spine_transform_constraint_set_is_active(spine_transform_constraint constraint, int isActive) {
    return _spine_transform_constraint_set_is_active(constraint, isActive);
  }

  late final _spine_transform_constraint_set_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, spine_bool)>>(
        'spine_transform_constraint_set_is_active',
      );
  late final _spine_transform_constraint_set_is_active = _spine_transform_constraint_set_is_activePtr
      .asFunction<void Function(spine_transform_constraint, int)>();

  /// OMITTED setToSetupPose()
  int spine_path_constraint_data_get_num_bones(spine_path_constraint_data data) {
    return _spine_path_constraint_data_get_num_bones(data);
  }

  late final _spine_path_constraint_data_get_num_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint_data)>>(
        'spine_path_constraint_data_get_num_bones',
      );
  late final _spine_path_constraint_data_get_num_bones = _spine_path_constraint_data_get_num_bonesPtr
      .asFunction<int Function(spine_path_constraint_data)>();

  ffi.Pointer<spine_bone_data> spine_path_constraint_data_get_bones(spine_path_constraint_data data) {
    return _spine_path_constraint_data_get_bones(data);
  }

  late final _spine_path_constraint_data_get_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_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<ffi.Pointer<spine_bone_data> Function(spine_path_constraint_data)>();

  spine_slot_data spine_path_constraint_data_get_target(spine_path_constraint_data data) {
    return _spine_path_constraint_data_get_target(data);
  }

  late final _spine_path_constraint_data_get_targetPtr =
      _lookup<ffi.NativeFunction<spine_slot_data Function(spine_path_constraint_data)>>(
        'spine_path_constraint_data_get_target',
      );
  late final _spine_path_constraint_data_get_target = _spine_path_constraint_data_get_targetPtr
      .asFunction<spine_slot_data Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_target(spine_path_constraint_data data, spine_slot_data target) {
    return _spine_path_constraint_data_set_target(data, target);
  }

  late final _spine_path_constraint_data_set_targetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, spine_slot_data)>>(
        'spine_path_constraint_data_set_target',
      );
  late final _spine_path_constraint_data_set_target = _spine_path_constraint_data_set_targetPtr
      .asFunction<void Function(spine_path_constraint_data, spine_slot_data)>();

  int spine_path_constraint_data_get_position_mode(spine_path_constraint_data data) {
    return _spine_path_constraint_data_get_position_mode(data);
  }

  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 data, int positionMode) {
    return _spine_path_constraint_data_set_position_mode(data, 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)>();

  int spine_path_constraint_data_get_spacing_mode(spine_path_constraint_data data) {
    return _spine_path_constraint_data_get_spacing_mode(data);
  }

  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 data, int spacingMode) {
    return _spine_path_constraint_data_set_spacing_mode(data, 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)>();

  int spine_path_constraint_data_get_rotate_mode(spine_path_constraint_data data) {
    return _spine_path_constraint_data_get_rotate_mode(data);
  }

  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 data, int rotateMode) {
    return _spine_path_constraint_data_set_rotate_mode(data, 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)>();

  double spine_path_constraint_data_get_offset_rotation(spine_path_constraint_data data) {
    return _spine_path_constraint_data_get_offset_rotation(data);
  }

  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 data, double offsetRotation) {
    return _spine_path_constraint_data_set_offset_rotation(data, 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)>();

  double spine_path_constraint_data_get_position(spine_path_constraint_data data) {
    return _spine_path_constraint_data_get_position(data);
  }

  late final _spine_path_constraint_data_get_positionPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_data)>>(
        'spine_path_constraint_data_get_position',
      );
  late final _spine_path_constraint_data_get_position = _spine_path_constraint_data_get_positionPtr
      .asFunction<double Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_position(spine_path_constraint_data data, double position) {
    return _spine_path_constraint_data_set_position(data, position);
  }

  late final _spine_path_constraint_data_set_positionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Float)>>(
        'spine_path_constraint_data_set_position',
      );
  late final _spine_path_constraint_data_set_position = _spine_path_constraint_data_set_positionPtr
      .asFunction<void Function(spine_path_constraint_data, double)>();

  double spine_path_constraint_data_get_spacing(spine_path_constraint_data data) {
    return _spine_path_constraint_data_get_spacing(data);
  }

  late final _spine_path_constraint_data_get_spacingPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_data)>>(
        'spine_path_constraint_data_get_spacing',
      );
  late final _spine_path_constraint_data_get_spacing = _spine_path_constraint_data_get_spacingPtr
      .asFunction<double Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_spacing(spine_path_constraint_data data, double spacing) {
    return _spine_path_constraint_data_set_spacing(data, spacing);
  }

  late final _spine_path_constraint_data_set_spacingPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Float)>>(
        'spine_path_constraint_data_set_spacing',
      );
  late final _spine_path_constraint_data_set_spacing = _spine_path_constraint_data_set_spacingPtr
      .asFunction<void Function(spine_path_constraint_data, double)>();

  double spine_path_constraint_data_get_mix_rotate(spine_path_constraint_data data) {
    return _spine_path_constraint_data_get_mix_rotate(data);
  }

  late final _spine_path_constraint_data_get_mix_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_data)>>(
        'spine_path_constraint_data_get_mix_rotate',
      );
  late final _spine_path_constraint_data_get_mix_rotate = _spine_path_constraint_data_get_mix_rotatePtr
      .asFunction<double Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_mix_rotate(spine_path_constraint_data data, double mixRotate) {
    return _spine_path_constraint_data_set_mix_rotate(data, mixRotate);
  }

  late final _spine_path_constraint_data_set_mix_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Float)>>(
        'spine_path_constraint_data_set_mix_rotate',
      );
  late final _spine_path_constraint_data_set_mix_rotate = _spine_path_constraint_data_set_mix_rotatePtr
      .asFunction<void Function(spine_path_constraint_data, double)>();

  double spine_path_constraint_data_get_mix_x(spine_path_constraint_data data) {
    return _spine_path_constraint_data_get_mix_x(data);
  }

  late final _spine_path_constraint_data_get_mix_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_data)>>(
        'spine_path_constraint_data_get_mix_x',
      );
  late final _spine_path_constraint_data_get_mix_x = _spine_path_constraint_data_get_mix_xPtr
      .asFunction<double Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_mix_x(spine_path_constraint_data data, double mixX) {
    return _spine_path_constraint_data_set_mix_x(data, mixX);
  }

  late final _spine_path_constraint_data_set_mix_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Float)>>(
        'spine_path_constraint_data_set_mix_x',
      );
  late final _spine_path_constraint_data_set_mix_x = _spine_path_constraint_data_set_mix_xPtr
      .asFunction<void Function(spine_path_constraint_data, double)>();

  double spine_path_constraint_data_get_mix_y(spine_path_constraint_data data) {
    return _spine_path_constraint_data_get_mix_y(data);
  }

  late final _spine_path_constraint_data_get_mix_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_data)>>(
        'spine_path_constraint_data_get_mix_y',
      );
  late final _spine_path_constraint_data_get_mix_y = _spine_path_constraint_data_get_mix_yPtr
      .asFunction<double Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_mix_y(spine_path_constraint_data data, double mixY) {
    return _spine_path_constraint_data_set_mix_y(data, mixY);
  }

  late final _spine_path_constraint_data_set_mix_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Float)>>(
        'spine_path_constraint_data_set_mix_y',
      );
  late final _spine_path_constraint_data_set_mix_y = _spine_path_constraint_data_set_mix_yPtr
      .asFunction<void Function(spine_path_constraint_data, double)>();

  void spine_path_constraint_update(spine_path_constraint constraint) {
    return _spine_path_constraint_update(constraint);
  }

  late final _spine_path_constraint_updatePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint)>>(
    'spine_path_constraint_update',
  );
  late final _spine_path_constraint_update = _spine_path_constraint_updatePtr
      .asFunction<void Function(spine_path_constraint)>();

  int spine_path_constraint_get_order(spine_path_constraint constraint) {
    return _spine_path_constraint_get_order(constraint);
  }

  late final _spine_path_constraint_get_orderPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint)>>('spine_path_constraint_get_order');
  late final _spine_path_constraint_get_order = _spine_path_constraint_get_orderPtr
      .asFunction<int Function(spine_path_constraint)>();

  spine_path_constraint_data spine_path_constraint_get_data(spine_path_constraint constraint) {
    return _spine_path_constraint_get_data(constraint);
  }

  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)>();

  int spine_path_constraint_get_num_bones(spine_path_constraint constraint) {
    return _spine_path_constraint_get_num_bones(constraint);
  }

  late final _spine_path_constraint_get_num_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint)>>('spine_path_constraint_get_num_bones');
  late final _spine_path_constraint_get_num_bones = _spine_path_constraint_get_num_bonesPtr
      .asFunction<int Function(spine_path_constraint)>();

  ffi.Pointer<spine_bone> spine_path_constraint_get_bones(spine_path_constraint constraint) {
    return _spine_path_constraint_get_bones(constraint);
  }

  late final _spine_path_constraint_get_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_bone> Function(spine_path_constraint)>>(
        'spine_path_constraint_get_bones',
      );
  late final _spine_path_constraint_get_bones = _spine_path_constraint_get_bonesPtr
      .asFunction<ffi.Pointer<spine_bone> Function(spine_path_constraint)>();

  spine_slot spine_path_constraint_get_target(spine_path_constraint constraint) {
    return _spine_path_constraint_get_target(constraint);
  }

  late final _spine_path_constraint_get_targetPtr =
      _lookup<ffi.NativeFunction<spine_slot Function(spine_path_constraint)>>('spine_path_constraint_get_target');
  late final _spine_path_constraint_get_target = _spine_path_constraint_get_targetPtr
      .asFunction<spine_slot Function(spine_path_constraint)>();

  void spine_path_constraint_set_target(spine_path_constraint constraint, spine_slot target) {
    return _spine_path_constraint_set_target(constraint, target);
  }

  late final _spine_path_constraint_set_targetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, spine_slot)>>(
        'spine_path_constraint_set_target',
      );
  late final _spine_path_constraint_set_target = _spine_path_constraint_set_targetPtr
      .asFunction<void Function(spine_path_constraint, spine_slot)>();

  double spine_path_constraint_get_position(spine_path_constraint constraint) {
    return _spine_path_constraint_get_position(constraint);
  }

  late final _spine_path_constraint_get_positionPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint)>>('spine_path_constraint_get_position');
  late final _spine_path_constraint_get_position = _spine_path_constraint_get_positionPtr
      .asFunction<double Function(spine_path_constraint)>();

  void spine_path_constraint_set_position(spine_path_constraint constraint, double position) {
    return _spine_path_constraint_set_position(constraint, position);
  }

  late final _spine_path_constraint_set_positionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, ffi.Float)>>(
        'spine_path_constraint_set_position',
      );
  late final _spine_path_constraint_set_position = _spine_path_constraint_set_positionPtr
      .asFunction<void Function(spine_path_constraint, double)>();

  double spine_path_constraint_get_spacing(spine_path_constraint constraint) {
    return _spine_path_constraint_get_spacing(constraint);
  }

  late final _spine_path_constraint_get_spacingPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint)>>('spine_path_constraint_get_spacing');
  late final _spine_path_constraint_get_spacing = _spine_path_constraint_get_spacingPtr
      .asFunction<double Function(spine_path_constraint)>();

  void spine_path_constraint_set_spacing(spine_path_constraint constraint, double spacing) {
    return _spine_path_constraint_set_spacing(constraint, spacing);
  }

  late final _spine_path_constraint_set_spacingPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, ffi.Float)>>(
        'spine_path_constraint_set_spacing',
      );
  late final _spine_path_constraint_set_spacing = _spine_path_constraint_set_spacingPtr
      .asFunction<void Function(spine_path_constraint, double)>();

  double spine_path_constraint_get_mix_rotate(spine_path_constraint constraint) {
    return _spine_path_constraint_get_mix_rotate(constraint);
  }

  late final _spine_path_constraint_get_mix_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint)>>('spine_path_constraint_get_mix_rotate');
  late final _spine_path_constraint_get_mix_rotate = _spine_path_constraint_get_mix_rotatePtr
      .asFunction<double Function(spine_path_constraint)>();

  void spine_path_constraint_set_mix_rotate(spine_path_constraint constraint, double mixRotate) {
    return _spine_path_constraint_set_mix_rotate(constraint, mixRotate);
  }

  late final _spine_path_constraint_set_mix_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, ffi.Float)>>(
        'spine_path_constraint_set_mix_rotate',
      );
  late final _spine_path_constraint_set_mix_rotate = _spine_path_constraint_set_mix_rotatePtr
      .asFunction<void Function(spine_path_constraint, double)>();

  double spine_path_constraint_get_mix_x(spine_path_constraint constraint) {
    return _spine_path_constraint_get_mix_x(constraint);
  }

  late final _spine_path_constraint_get_mix_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint)>>('spine_path_constraint_get_mix_x');
  late final _spine_path_constraint_get_mix_x = _spine_path_constraint_get_mix_xPtr
      .asFunction<double Function(spine_path_constraint)>();

  void spine_path_constraint_set_mix_x(spine_path_constraint constraint, double mixX) {
    return _spine_path_constraint_set_mix_x(constraint, mixX);
  }

  late final _spine_path_constraint_set_mix_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, ffi.Float)>>(
        'spine_path_constraint_set_mix_x',
      );
  late final _spine_path_constraint_set_mix_x = _spine_path_constraint_set_mix_xPtr
      .asFunction<void Function(spine_path_constraint, double)>();

  double spine_path_constraint_get_mix_y(spine_path_constraint constraint) {
    return _spine_path_constraint_get_mix_y(constraint);
  }

  late final _spine_path_constraint_get_mix_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint)>>('spine_path_constraint_get_mix_y');
  late final _spine_path_constraint_get_mix_y = _spine_path_constraint_get_mix_yPtr
      .asFunction<double Function(spine_path_constraint)>();

  void spine_path_constraint_set_mix_y(spine_path_constraint constraint, double mixY) {
    return _spine_path_constraint_set_mix_y(constraint, mixY);
  }

  late final _spine_path_constraint_set_mix_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, ffi.Float)>>(
        'spine_path_constraint_set_mix_y',
      );
  late final _spine_path_constraint_set_mix_y = _spine_path_constraint_set_mix_yPtr
      .asFunction<void Function(spine_path_constraint, double)>();

  int spine_path_constraint_get_is_active(spine_path_constraint constraint) {
    return _spine_path_constraint_get_is_active(constraint);
  }

  late final _spine_path_constraint_get_is_activePtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_path_constraint)>>('spine_path_constraint_get_is_active');
  late final _spine_path_constraint_get_is_active = _spine_path_constraint_get_is_activePtr
      .asFunction<int Function(spine_path_constraint)>();

  void spine_path_constraint_set_is_active(spine_path_constraint constraint, int isActive) {
    return _spine_path_constraint_set_is_active(constraint, isActive);
  }

  late final _spine_path_constraint_set_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, spine_bool)>>(
        'spine_path_constraint_set_is_active',
      );
  late final _spine_path_constraint_set_is_active = _spine_path_constraint_set_is_activePtr
      .asFunction<void Function(spine_path_constraint, int)>();

  /// OMITTED setToSetupPose()
  void spine_physics_constraint_data_set_bone(spine_physics_constraint_data data, spine_bone_data bone) {
    return _spine_physics_constraint_data_set_bone(data, 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)>();

  spine_bone_data spine_physics_constraint_data_get_bone(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_bone(data);
  }

  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_x(spine_physics_constraint_data data, double x) {
    return _spine_physics_constraint_data_set_x(data, 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_x(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_x(data);
  }

  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_y(spine_physics_constraint_data data, double y) {
    return _spine_physics_constraint_data_set_y(data, 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_y(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_y(data);
  }

  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_rotate(spine_physics_constraint_data data, double rotate) {
    return _spine_physics_constraint_data_set_rotate(data, 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_rotate(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_rotate(data);
  }

  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_scale_x(spine_physics_constraint_data data, double scaleX) {
    return _spine_physics_constraint_data_set_scale_x(data, 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_scale_x(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_scale_x(data);
  }

  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_shear_x(spine_physics_constraint_data data, double shearX) {
    return _spine_physics_constraint_data_set_shear_x(data, 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_shear_x(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_shear_x(data);
  }

  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_limit(spine_physics_constraint_data data, double limit) {
    return _spine_physics_constraint_data_set_limit(data, 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)>();

  double spine_physics_constraint_data_get_limit(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_limit(data);
  }

  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_step(spine_physics_constraint_data data, double step) {
    return _spine_physics_constraint_data_set_step(data, 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_step(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_step(data);
  }

  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_inertia(spine_physics_constraint_data data, double inertia) {
    return _spine_physics_constraint_data_set_inertia(data, inertia);
  }

  late final _spine_physics_constraint_data_set_inertiaPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
        'spine_physics_constraint_data_set_inertia',
      );
  late final _spine_physics_constraint_data_set_inertia = _spine_physics_constraint_data_set_inertiaPtr
      .asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_inertia(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_inertia(data);
  }

  late final _spine_physics_constraint_data_get_inertiaPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_get_inertia',
      );
  late final _spine_physics_constraint_data_get_inertia = _spine_physics_constraint_data_get_inertiaPtr
      .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_strength(spine_physics_constraint_data data, double strength) {
    return _spine_physics_constraint_data_set_strength(data, strength);
  }

  late final _spine_physics_constraint_data_set_strengthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
        'spine_physics_constraint_data_set_strength',
      );
  late final _spine_physics_constraint_data_set_strength = _spine_physics_constraint_data_set_strengthPtr
      .asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_strength(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_strength(data);
  }

  late final _spine_physics_constraint_data_get_strengthPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_get_strength',
      );
  late final _spine_physics_constraint_data_get_strength = _spine_physics_constraint_data_get_strengthPtr
      .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_damping(spine_physics_constraint_data data, double damping) {
    return _spine_physics_constraint_data_set_damping(data, damping);
  }

  late final _spine_physics_constraint_data_set_dampingPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
        'spine_physics_constraint_data_set_damping',
      );
  late final _spine_physics_constraint_data_set_damping = _spine_physics_constraint_data_set_dampingPtr
      .asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_damping(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_damping(data);
  }

  late final _spine_physics_constraint_data_get_dampingPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_get_damping',
      );
  late final _spine_physics_constraint_data_get_damping = _spine_physics_constraint_data_get_dampingPtr
      .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_mass_inverse(spine_physics_constraint_data data, double massInverse) {
    return _spine_physics_constraint_data_set_mass_inverse(data, massInverse);
  }

  late final _spine_physics_constraint_data_set_mass_inversePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
        'spine_physics_constraint_data_set_mass_inverse',
      );
  late final _spine_physics_constraint_data_set_mass_inverse = _spine_physics_constraint_data_set_mass_inversePtr
      .asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_mass_inverse(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_mass_inverse(data);
  }

  late final _spine_physics_constraint_data_get_mass_inversePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_get_mass_inverse',
      );
  late final _spine_physics_constraint_data_get_mass_inverse = _spine_physics_constraint_data_get_mass_inversePtr
      .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_wind(spine_physics_constraint_data data, double wind) {
    return _spine_physics_constraint_data_set_wind(data, wind);
  }

  late final _spine_physics_constraint_data_set_windPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
        'spine_physics_constraint_data_set_wind',
      );
  late final _spine_physics_constraint_data_set_wind = _spine_physics_constraint_data_set_windPtr
      .asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_wind(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_wind(data);
  }

  late final _spine_physics_constraint_data_get_windPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_get_wind',
      );
  late final _spine_physics_constraint_data_get_wind = _spine_physics_constraint_data_get_windPtr
      .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_gravity(spine_physics_constraint_data data, double gravity) {
    return _spine_physics_constraint_data_set_gravity(data, gravity);
  }

  late final _spine_physics_constraint_data_set_gravityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
        'spine_physics_constraint_data_set_gravity',
      );
  late final _spine_physics_constraint_data_set_gravity = _spine_physics_constraint_data_set_gravityPtr
      .asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_gravity(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_gravity(data);
  }

  late final _spine_physics_constraint_data_get_gravityPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_get_gravity',
      );
  late final _spine_physics_constraint_data_get_gravity = _spine_physics_constraint_data_get_gravityPtr
      .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_mix(spine_physics_constraint_data data, double mix) {
    return _spine_physics_constraint_data_set_mix(data, mix);
  }

  late final _spine_physics_constraint_data_set_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
        'spine_physics_constraint_data_set_mix',
      );
  late final _spine_physics_constraint_data_set_mix = _spine_physics_constraint_data_set_mixPtr
      .asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_mix(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_get_mix(data);
  }

  late final _spine_physics_constraint_data_get_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_get_mix',
      );
  late final _spine_physics_constraint_data_get_mix = _spine_physics_constraint_data_get_mixPtr
      .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_inertia_global(spine_physics_constraint_data data, int inertiaGlobal) {
    return _spine_physics_constraint_data_set_inertia_global(data, inertiaGlobal);
  }

  late final _spine_physics_constraint_data_set_inertia_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_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, int)>();

  int spine_physics_constraint_data_is_inertia_global(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_is_inertia_global(data);
  }

  late final _spine_physics_constraint_data_is_inertia_globalPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_is_inertia_global',
      );
  late final _spine_physics_constraint_data_is_inertia_global = _spine_physics_constraint_data_is_inertia_globalPtr
      .asFunction<int Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_strength_global(spine_physics_constraint_data data, int strengthGlobal) {
    return _spine_physics_constraint_data_set_strength_global(data, strengthGlobal);
  }

  late final _spine_physics_constraint_data_set_strength_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_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, int)>();

  int spine_physics_constraint_data_is_strength_global(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_is_strength_global(data);
  }

  late final _spine_physics_constraint_data_is_strength_globalPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_is_strength_global',
      );
  late final _spine_physics_constraint_data_is_strength_global = _spine_physics_constraint_data_is_strength_globalPtr
      .asFunction<int Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_damping_global(spine_physics_constraint_data data, int dampingGlobal) {
    return _spine_physics_constraint_data_set_damping_global(data, dampingGlobal);
  }

  late final _spine_physics_constraint_data_set_damping_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_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, int)>();

  int spine_physics_constraint_data_is_damping_global(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_is_damping_global(data);
  }

  late final _spine_physics_constraint_data_is_damping_globalPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_is_damping_global',
      );
  late final _spine_physics_constraint_data_is_damping_global = _spine_physics_constraint_data_is_damping_globalPtr
      .asFunction<int Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_mass_global(spine_physics_constraint_data data, int massGlobal) {
    return _spine_physics_constraint_data_set_mass_global(data, massGlobal);
  }

  late final _spine_physics_constraint_data_set_mass_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_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, int)>();

  int spine_physics_constraint_data_is_mass_global(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_is_mass_global(data);
  }

  late final _spine_physics_constraint_data_is_mass_globalPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_is_mass_global',
      );
  late final _spine_physics_constraint_data_is_mass_global = _spine_physics_constraint_data_is_mass_globalPtr
      .asFunction<int Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_wind_global(spine_physics_constraint_data data, int windGlobal) {
    return _spine_physics_constraint_data_set_wind_global(data, windGlobal);
  }

  late final _spine_physics_constraint_data_set_wind_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_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, int)>();

  int spine_physics_constraint_data_is_wind_global(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_is_wind_global(data);
  }

  late final _spine_physics_constraint_data_is_wind_globalPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_is_wind_global',
      );
  late final _spine_physics_constraint_data_is_wind_global = _spine_physics_constraint_data_is_wind_globalPtr
      .asFunction<int Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_gravity_global(spine_physics_constraint_data data, int gravityGlobal) {
    return _spine_physics_constraint_data_set_gravity_global(data, gravityGlobal);
  }

  late final _spine_physics_constraint_data_set_gravity_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_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, int)>();

  int spine_physics_constraint_data_is_gravity_global(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_is_gravity_global(data);
  }

  late final _spine_physics_constraint_data_is_gravity_globalPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_is_gravity_global',
      );
  late final _spine_physics_constraint_data_is_gravity_global = _spine_physics_constraint_data_is_gravity_globalPtr
      .asFunction<int Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_mix_global(spine_physics_constraint_data data, int mixGlobal) {
    return _spine_physics_constraint_data_set_mix_global(data, mixGlobal);
  }

  late final _spine_physics_constraint_data_set_mix_globalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_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, int)>();

  int spine_physics_constraint_data_is_mix_global(spine_physics_constraint_data data) {
    return _spine_physics_constraint_data_is_mix_global(data);
  }

  late final _spine_physics_constraint_data_is_mix_globalPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
        'spine_physics_constraint_data_is_mix_global',
      );
  late final _spine_physics_constraint_data_is_mix_global = _spine_physics_constraint_data_is_mix_globalPtr
      .asFunction<int Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_set_bone(spine_physics_constraint constraint, spine_bone bone) {
    return _spine_physics_constraint_set_bone(constraint, bone);
  }

  late final _spine_physics_constraint_set_bonePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, spine_bone)>>(
        '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)>();

  spine_bone spine_physics_constraint_get_bone(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_bone(constraint);
  }

  late final _spine_physics_constraint_get_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_physics_constraint)>>('spine_physics_constraint_get_bone');
  late final _spine_physics_constraint_get_bone = _spine_physics_constraint_get_bonePtr
      .asFunction<spine_bone Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_inertia(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_inertia(constraint, value);
  }

  late final _spine_physics_constraint_set_inertiaPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_inertia',
      );
  late final _spine_physics_constraint_set_inertia = _spine_physics_constraint_set_inertiaPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_inertia(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_inertia(constraint);
  }

  late final _spine_physics_constraint_get_inertiaPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_inertia');
  late final _spine_physics_constraint_get_inertia = _spine_physics_constraint_get_inertiaPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_strength(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_strength(constraint, value);
  }

  late final _spine_physics_constraint_set_strengthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_strength',
      );
  late final _spine_physics_constraint_set_strength = _spine_physics_constraint_set_strengthPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_strength(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_strength(constraint);
  }

  late final _spine_physics_constraint_get_strengthPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
        'spine_physics_constraint_get_strength',
      );
  late final _spine_physics_constraint_get_strength = _spine_physics_constraint_get_strengthPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_damping(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_damping(constraint, value);
  }

  late final _spine_physics_constraint_set_dampingPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_damping',
      );
  late final _spine_physics_constraint_set_damping = _spine_physics_constraint_set_dampingPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_damping(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_damping(constraint);
  }

  late final _spine_physics_constraint_get_dampingPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_damping');
  late final _spine_physics_constraint_get_damping = _spine_physics_constraint_get_dampingPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_mass_inverse(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_mass_inverse(constraint, value);
  }

  late final _spine_physics_constraint_set_mass_inversePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_mass_inverse',
      );
  late final _spine_physics_constraint_set_mass_inverse = _spine_physics_constraint_set_mass_inversePtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_mass_inverse(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_mass_inverse(constraint);
  }

  late final _spine_physics_constraint_get_mass_inversePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
        'spine_physics_constraint_get_mass_inverse',
      );
  late final _spine_physics_constraint_get_mass_inverse = _spine_physics_constraint_get_mass_inversePtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_wind(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_wind(constraint, value);
  }

  late final _spine_physics_constraint_set_windPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_wind',
      );
  late final _spine_physics_constraint_set_wind = _spine_physics_constraint_set_windPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_wind(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_wind(constraint);
  }

  late final _spine_physics_constraint_get_windPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_wind');
  late final _spine_physics_constraint_get_wind = _spine_physics_constraint_get_windPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_gravity(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_gravity(constraint, value);
  }

  late final _spine_physics_constraint_set_gravityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_gravity',
      );
  late final _spine_physics_constraint_set_gravity = _spine_physics_constraint_set_gravityPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_gravity(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_gravity(constraint);
  }

  late final _spine_physics_constraint_get_gravityPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_gravity');
  late final _spine_physics_constraint_get_gravity = _spine_physics_constraint_get_gravityPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_mix(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_mix(constraint, value);
  }

  late final _spine_physics_constraint_set_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_mix',
      );
  late final _spine_physics_constraint_set_mix = _spine_physics_constraint_set_mixPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_mix(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_mix(constraint);
  }

  late final _spine_physics_constraint_get_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_mix');
  late final _spine_physics_constraint_get_mix = _spine_physics_constraint_get_mixPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_reset(spine_physics_constraint constraint, int value) {
    return _spine_physics_constraint_set_reset(constraint, value);
  }

  late final _spine_physics_constraint_set_resetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, spine_bool)>>(
        'spine_physics_constraint_set_reset',
      );
  late final _spine_physics_constraint_set_reset = _spine_physics_constraint_set_resetPtr
      .asFunction<void Function(spine_physics_constraint, int)>();

  int spine_physics_constraint_get_reset(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_reset(constraint);
  }

  late final _spine_physics_constraint_get_resetPtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint)>>('spine_physics_constraint_get_reset');
  late final _spine_physics_constraint_get_reset = _spine_physics_constraint_get_resetPtr
      .asFunction<int Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_ux(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_ux(constraint, value);
  }

  late final _spine_physics_constraint_set_uxPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_ux',
      );
  late final _spine_physics_constraint_set_ux = _spine_physics_constraint_set_uxPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_ux(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_ux(constraint);
  }

  late final _spine_physics_constraint_get_uxPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_ux');
  late final _spine_physics_constraint_get_ux = _spine_physics_constraint_get_uxPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_uy(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_uy(constraint, value);
  }

  late final _spine_physics_constraint_set_uyPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_uy',
      );
  late final _spine_physics_constraint_set_uy = _spine_physics_constraint_set_uyPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_uy(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_uy(constraint);
  }

  late final _spine_physics_constraint_get_uyPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_uy');
  late final _spine_physics_constraint_get_uy = _spine_physics_constraint_get_uyPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_cx(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_cx(constraint, value);
  }

  late final _spine_physics_constraint_set_cxPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_cx',
      );
  late final _spine_physics_constraint_set_cx = _spine_physics_constraint_set_cxPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_cx(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_cx(constraint);
  }

  late final _spine_physics_constraint_get_cxPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_cx');
  late final _spine_physics_constraint_get_cx = _spine_physics_constraint_get_cxPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_cy(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_cy(constraint, value);
  }

  late final _spine_physics_constraint_set_cyPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_cy',
      );
  late final _spine_physics_constraint_set_cy = _spine_physics_constraint_set_cyPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_cy(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_cy(constraint);
  }

  late final _spine_physics_constraint_get_cyPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_cy');
  late final _spine_physics_constraint_get_cy = _spine_physics_constraint_get_cyPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_tx(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_tx(constraint, value);
  }

  late final _spine_physics_constraint_set_txPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_tx',
      );
  late final _spine_physics_constraint_set_tx = _spine_physics_constraint_set_txPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_tx(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_tx(constraint);
  }

  late final _spine_physics_constraint_get_txPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_tx');
  late final _spine_physics_constraint_get_tx = _spine_physics_constraint_get_txPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_ty(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_ty(constraint, value);
  }

  late final _spine_physics_constraint_set_tyPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_ty',
      );
  late final _spine_physics_constraint_set_ty = _spine_physics_constraint_set_tyPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_ty(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_ty(constraint);
  }

  late final _spine_physics_constraint_get_tyPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_ty');
  late final _spine_physics_constraint_get_ty = _spine_physics_constraint_get_tyPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_x_offset(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_x_offset(constraint, value);
  }

  late final _spine_physics_constraint_set_x_offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_x_offset',
      );
  late final _spine_physics_constraint_set_x_offset = _spine_physics_constraint_set_x_offsetPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_x_offset(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_x_offset(constraint);
  }

  late final _spine_physics_constraint_get_x_offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
        'spine_physics_constraint_get_x_offset',
      );
  late final _spine_physics_constraint_get_x_offset = _spine_physics_constraint_get_x_offsetPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_x_velocity(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_x_velocity(constraint, value);
  }

  late final _spine_physics_constraint_set_x_velocityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_x_velocity',
      );
  late final _spine_physics_constraint_set_x_velocity = _spine_physics_constraint_set_x_velocityPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_x_velocity(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_x_velocity(constraint);
  }

  late final _spine_physics_constraint_get_x_velocityPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
        'spine_physics_constraint_get_x_velocity',
      );
  late final _spine_physics_constraint_get_x_velocity = _spine_physics_constraint_get_x_velocityPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_y_offset(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_y_offset(constraint, value);
  }

  late final _spine_physics_constraint_set_y_offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_y_offset',
      );
  late final _spine_physics_constraint_set_y_offset = _spine_physics_constraint_set_y_offsetPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_y_offset(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_y_offset(constraint);
  }

  late final _spine_physics_constraint_get_y_offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
        'spine_physics_constraint_get_y_offset',
      );
  late final _spine_physics_constraint_get_y_offset = _spine_physics_constraint_get_y_offsetPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_y_velocity(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_y_velocity(constraint, value);
  }

  late final _spine_physics_constraint_set_y_velocityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_y_velocity',
      );
  late final _spine_physics_constraint_set_y_velocity = _spine_physics_constraint_set_y_velocityPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_y_velocity(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_y_velocity(constraint);
  }

  late final _spine_physics_constraint_get_y_velocityPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
        'spine_physics_constraint_get_y_velocity',
      );
  late final _spine_physics_constraint_get_y_velocity = _spine_physics_constraint_get_y_velocityPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_rotate_offset(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_rotate_offset(constraint, value);
  }

  late final _spine_physics_constraint_set_rotate_offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_rotate_offset',
      );
  late final _spine_physics_constraint_set_rotate_offset = _spine_physics_constraint_set_rotate_offsetPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_rotate_offset(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_rotate_offset(constraint);
  }

  late final _spine_physics_constraint_get_rotate_offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
        'spine_physics_constraint_get_rotate_offset',
      );
  late final _spine_physics_constraint_get_rotate_offset = _spine_physics_constraint_get_rotate_offsetPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_rotate_velocity(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_rotate_velocity(constraint, value);
  }

  late final _spine_physics_constraint_set_rotate_velocityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_rotate_velocity',
      );
  late final _spine_physics_constraint_set_rotate_velocity = _spine_physics_constraint_set_rotate_velocityPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_rotate_velocity(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_rotate_velocity(constraint);
  }

  late final _spine_physics_constraint_get_rotate_velocityPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
        'spine_physics_constraint_get_rotate_velocity',
      );
  late final _spine_physics_constraint_get_rotate_velocity = _spine_physics_constraint_get_rotate_velocityPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_scale_offset(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_scale_offset(constraint, value);
  }

  late final _spine_physics_constraint_set_scale_offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_scale_offset',
      );
  late final _spine_physics_constraint_set_scale_offset = _spine_physics_constraint_set_scale_offsetPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_scale_offset(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_scale_offset(constraint);
  }

  late final _spine_physics_constraint_get_scale_offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
        'spine_physics_constraint_get_scale_offset',
      );
  late final _spine_physics_constraint_get_scale_offset = _spine_physics_constraint_get_scale_offsetPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_scale_velocity(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_scale_velocity(constraint, value);
  }

  late final _spine_physics_constraint_set_scale_velocityPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_scale_velocity',
      );
  late final _spine_physics_constraint_set_scale_velocity = _spine_physics_constraint_set_scale_velocityPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_scale_velocity(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_scale_velocity(constraint);
  }

  late final _spine_physics_constraint_get_scale_velocityPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
        'spine_physics_constraint_get_scale_velocity',
      );
  late final _spine_physics_constraint_get_scale_velocity = _spine_physics_constraint_get_scale_velocityPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_active(spine_physics_constraint constraint, int value) {
    return _spine_physics_constraint_set_active(constraint, value);
  }

  late final _spine_physics_constraint_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, spine_bool)>>(
        'spine_physics_constraint_set_active',
      );
  late final _spine_physics_constraint_set_active = _spine_physics_constraint_set_activePtr
      .asFunction<void Function(spine_physics_constraint, int)>();

  int spine_physics_constraint_is_active(spine_physics_constraint constraint) {
    return _spine_physics_constraint_is_active(constraint);
  }

  late final _spine_physics_constraint_is_activePtr =
      _lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint)>>('spine_physics_constraint_is_active');
  late final _spine_physics_constraint_is_active = _spine_physics_constraint_is_activePtr
      .asFunction<int Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_remaining(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_remaining(constraint, value);
  }

  late final _spine_physics_constraint_set_remainingPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_remaining',
      );
  late final _spine_physics_constraint_set_remaining = _spine_physics_constraint_set_remainingPtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_remaining(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_remaining(constraint);
  }

  late final _spine_physics_constraint_get_remainingPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
        'spine_physics_constraint_get_remaining',
      );
  late final _spine_physics_constraint_get_remaining = _spine_physics_constraint_get_remainingPtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_last_time(spine_physics_constraint constraint, double value) {
    return _spine_physics_constraint_set_last_time(constraint, value);
  }

  late final _spine_physics_constraint_set_last_timePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
        'spine_physics_constraint_set_last_time',
      );
  late final _spine_physics_constraint_set_last_time = _spine_physics_constraint_set_last_timePtr
      .asFunction<void Function(spine_physics_constraint, double)>();

  double spine_physics_constraint_get_last_time(spine_physics_constraint constraint) {
    return _spine_physics_constraint_get_last_time(constraint);
  }

  late final _spine_physics_constraint_get_last_timePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
        'spine_physics_constraint_get_last_time',
      );
  late final _spine_physics_constraint_get_last_time = _spine_physics_constraint_get_last_timePtr
      .asFunction<double Function(spine_physics_constraint)>();

  void spine_physics_constraint_reset(spine_physics_constraint constraint) {
    return _spine_physics_constraint_reset(constraint);
  }

  late final _spine_physics_constraint_resetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint)>>('spine_physics_constraint_reset');
  late final _spine_physics_constraint_reset = _spine_physics_constraint_resetPtr
      .asFunction<void Function(spine_physics_constraint)>();

  /// Omitted setToSetupPose()
  void spine_physics_constraint_update(spine_physics_constraint data, int physics) {
    return _spine_physics_constraint_update(data, physics);
  }

  late final _spine_physics_constraint_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Int32)>>(
        'spine_physics_constraint_update',
      );
  late final _spine_physics_constraint_update = _spine_physics_constraint_updatePtr
      .asFunction<void Function(spine_physics_constraint, int)>();

  void spine_physics_constraint_translate(spine_physics_constraint data, double x, double y) {
    return _spine_physics_constraint_translate(data, 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)>();

  void spine_physics_constraint_rotate(spine_physics_constraint data, double x, double y, double degrees) {
    return _spine_physics_constraint_rotate(data, 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)>();

  /// OMITTED copy()
  void spine_sequence_apply(spine_sequence sequence, spine_slot slot, spine_attachment attachment) {
    return _spine_sequence_apply(sequence, slot, attachment);
  }

  late final _spine_sequence_applyPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, spine_slot, spine_attachment)>>(
        'spine_sequence_apply',
      );
  late final _spine_sequence_apply = _spine_sequence_applyPtr
      .asFunction<void Function(spine_sequence, spine_slot, spine_attachment)>();

  ffi.Pointer<utf8> spine_sequence_get_path(spine_sequence sequence, ffi.Pointer<utf8> basePath, int index) {
    return _spine_sequence_get_path(sequence, basePath, index);
  }

  late final _spine_sequence_get_pathPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_sequence, ffi.Pointer<utf8>, ffi.Int32)>>(
        'spine_sequence_get_path',
      );
  late final _spine_sequence_get_path = _spine_sequence_get_pathPtr
      .asFunction<ffi.Pointer<utf8> Function(spine_sequence, ffi.Pointer<utf8>, int)>();

  int spine_sequence_get_id(spine_sequence sequence) {
    return _spine_sequence_get_id(sequence);
  }

  late final _spine_sequence_get_idPtr = _lookup<ffi.NativeFunction<ffi.Int32 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 sequence, int id) {
    return _spine_sequence_set_id(sequence, id);
  }

  late final _spine_sequence_set_idPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int32)>>(
    '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 sequence) {
    return _spine_sequence_get_start(sequence);
  }

  late final _spine_sequence_get_startPtr = _lookup<ffi.NativeFunction<ffi.Int32 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 sequence, int start) {
    return _spine_sequence_set_start(sequence, start);
  }

  late final _spine_sequence_set_startPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int32)>>(
    '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 sequence) {
    return _spine_sequence_get_digits(sequence);
  }

  late final _spine_sequence_get_digitsPtr = _lookup<ffi.NativeFunction<ffi.Int32 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 sequence, int digits) {
    return _spine_sequence_set_digits(sequence, digits);
  }

  late final _spine_sequence_set_digitsPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int32)>>(
    'spine_sequence_set_digits',
  );
  late final _spine_sequence_set_digits = _spine_sequence_set_digitsPtr
      .asFunction<void Function(spine_sequence, int)>();

  int spine_sequence_get_setup_index(spine_sequence sequence) {
    return _spine_sequence_get_setup_index(sequence);
  }

  late final _spine_sequence_get_setup_indexPtr = _lookup<ffi.NativeFunction<ffi.Int32 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 sequence, int setupIndex) {
    return _spine_sequence_set_setup_index(sequence, setupIndex);
  }

  late final _spine_sequence_set_setup_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int32)>>('spine_sequence_set_setup_index');
  late final _spine_sequence_set_setup_index = _spine_sequence_set_setup_indexPtr
      .asFunction<void Function(spine_sequence, int)>();

  int spine_sequence_get_num_regions(spine_sequence sequence) {
    return _spine_sequence_get_num_regions(sequence);
  }

  late final _spine_sequence_get_num_regionsPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_sequence)>>(
    'spine_sequence_get_num_regions',
  );
  late final _spine_sequence_get_num_regions = _spine_sequence_get_num_regionsPtr
      .asFunction<int Function(spine_sequence)>();

  ffi.Pointer<spine_texture_region> spine_sequence_get_regions(spine_sequence sequence) {
    return _spine_sequence_get_regions(sequence);
  }

  late final _spine_sequence_get_regionsPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<spine_texture_region> Function(spine_sequence)>>(
        'spine_sequence_get_regions',
      );
  late final _spine_sequence_get_regions = _spine_sequence_get_regionsPtr
      .asFunction<ffi.Pointer<spine_texture_region> Function(spine_sequence)>();

  ffi.Pointer<ffi.Void> spine_texture_region_get_texture(spine_texture_region textureRegion) {
    return _spine_texture_region_get_texture(textureRegion);
  }

  late final _spine_texture_region_get_texturePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(spine_texture_region)>>(
        'spine_texture_region_get_texture',
      );
  late final _spine_texture_region_get_texture = _spine_texture_region_get_texturePtr
      .asFunction<ffi.Pointer<ffi.Void> Function(spine_texture_region)>();

  void spine_texture_region_set_texture(spine_texture_region textureRegion, ffi.Pointer<ffi.Void> texture) {
    return _spine_texture_region_set_texture(textureRegion, texture);
  }

  late final _spine_texture_region_set_texturePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Pointer<ffi.Void>)>>(
        'spine_texture_region_set_texture',
      );
  late final _spine_texture_region_set_texture = _spine_texture_region_set_texturePtr
      .asFunction<void Function(spine_texture_region, ffi.Pointer<ffi.Void>)>();

  double spine_texture_region_get_u(spine_texture_region textureRegion) {
    return _spine_texture_region_get_u(textureRegion);
  }

  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 textureRegion, double u) {
    return _spine_texture_region_set_u(textureRegion, u);
  }

  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 textureRegion) {
    return _spine_texture_region_get_v(textureRegion);
  }

  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 textureRegion, double v) {
    return _spine_texture_region_set_v(textureRegion, v);
  }

  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 textureRegion) {
    return _spine_texture_region_get_u2(textureRegion);
  }

  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 textureRegion, double u2) {
    return _spine_texture_region_set_u2(textureRegion, u2);
  }

  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 textureRegion) {
    return _spine_texture_region_get_v2(textureRegion);
  }

  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 textureRegion, double v2) {
    return _spine_texture_region_set_v2(textureRegion, v2);
  }

  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_degrees(spine_texture_region textureRegion) {
    return _spine_texture_region_get_degrees(textureRegion);
  }

  late final _spine_texture_region_get_degreesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_texture_region)>>('spine_texture_region_get_degrees');
  late final _spine_texture_region_get_degrees = _spine_texture_region_get_degreesPtr
      .asFunction<int Function(spine_texture_region)>();

  void spine_texture_region_set_degrees(spine_texture_region textureRegion, int degrees) {
    return _spine_texture_region_set_degrees(textureRegion, degrees);
  }

  late final _spine_texture_region_set_degreesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int32)>>(
        'spine_texture_region_set_degrees',
      );
  late final _spine_texture_region_set_degrees = _spine_texture_region_set_degreesPtr
      .asFunction<void Function(spine_texture_region, int)>();

  double spine_texture_region_get_offset_x(spine_texture_region textureRegion) {
    return _spine_texture_region_get_offset_x(textureRegion);
  }

  late final _spine_texture_region_get_offset_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>('spine_texture_region_get_offset_x');
  late final _spine_texture_region_get_offset_x = _spine_texture_region_get_offset_xPtr
      .asFunction<double Function(spine_texture_region)>();

  void spine_texture_region_set_offset_x(spine_texture_region textureRegion, double offsetX) {
    return _spine_texture_region_set_offset_x(textureRegion, offsetX);
  }

  late final _spine_texture_region_set_offset_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>(
        'spine_texture_region_set_offset_x',
      );
  late final _spine_texture_region_set_offset_x = _spine_texture_region_set_offset_xPtr
      .asFunction<void Function(spine_texture_region, double)>();

  double spine_texture_region_get_offset_y(spine_texture_region textureRegion) {
    return _spine_texture_region_get_offset_y(textureRegion);
  }

  late final _spine_texture_region_get_offset_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>('spine_texture_region_get_offset_y');
  late final _spine_texture_region_get_offset_y = _spine_texture_region_get_offset_yPtr
      .asFunction<double Function(spine_texture_region)>();

  void spine_texture_region_set_offset_y(spine_texture_region textureRegion, double offsetY) {
    return _spine_texture_region_set_offset_y(textureRegion, offsetY);
  }

  late final _spine_texture_region_set_offset_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>(
        'spine_texture_region_set_offset_y',
      );
  late final _spine_texture_region_set_offset_y = _spine_texture_region_set_offset_yPtr
      .asFunction<void Function(spine_texture_region, double)>();

  int spine_texture_region_get_width(spine_texture_region textureRegion) {
    return _spine_texture_region_get_width(textureRegion);
  }

  late final _spine_texture_region_get_widthPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_texture_region)>>(
    'spine_texture_region_get_width',
  );
  late final _spine_texture_region_get_width = _spine_texture_region_get_widthPtr
      .asFunction<int Function(spine_texture_region)>();

  void spine_texture_region_set_width(spine_texture_region textureRegion, int width) {
    return _spine_texture_region_set_width(textureRegion, width);
  }

  late final _spine_texture_region_set_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int32)>>('spine_texture_region_set_width');
  late final _spine_texture_region_set_width = _spine_texture_region_set_widthPtr
      .asFunction<void Function(spine_texture_region, int)>();

  int spine_texture_region_get_height(spine_texture_region textureRegion) {
    return _spine_texture_region_get_height(textureRegion);
  }

  late final _spine_texture_region_get_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_texture_region)>>('spine_texture_region_get_height');
  late final _spine_texture_region_get_height = _spine_texture_region_get_heightPtr
      .asFunction<int Function(spine_texture_region)>();

  void spine_texture_region_set_height(spine_texture_region textureRegion, int height) {
    return _spine_texture_region_set_height(textureRegion, height);
  }

  late final _spine_texture_region_set_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int32)>>(
        'spine_texture_region_set_height',
      );
  late final _spine_texture_region_set_height = _spine_texture_region_set_heightPtr
      .asFunction<void Function(spine_texture_region, int)>();

  int spine_texture_region_get_original_width(spine_texture_region textureRegion) {
    return _spine_texture_region_get_original_width(textureRegion);
  }

  late final _spine_texture_region_get_original_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_texture_region)>>('spine_texture_region_get_original_width');
  late final _spine_texture_region_get_original_width = _spine_texture_region_get_original_widthPtr
      .asFunction<int Function(spine_texture_region)>();

  void spine_texture_region_set_original_width(spine_texture_region textureRegion, int originalWidth) {
    return _spine_texture_region_set_original_width(textureRegion, originalWidth);
  }

  late final _spine_texture_region_set_original_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int32)>>(
        'spine_texture_region_set_original_width',
      );
  late final _spine_texture_region_set_original_width = _spine_texture_region_set_original_widthPtr
      .asFunction<void Function(spine_texture_region, int)>();

  int spine_texture_region_get_original_height(spine_texture_region textureRegion) {
    return _spine_texture_region_get_original_height(textureRegion);
  }

  late final _spine_texture_region_get_original_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_texture_region)>>('spine_texture_region_get_original_height');
  late final _spine_texture_region_get_original_height = _spine_texture_region_get_original_heightPtr
      .asFunction<int Function(spine_texture_region)>();

  void spine_texture_region_set_original_height(spine_texture_region textureRegion, int originalHeight) {
    return _spine_texture_region_set_original_height(textureRegion, originalHeight);
  }

  late final _spine_texture_region_set_original_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int32)>>(
        'spine_texture_region_set_original_height',
      );
  late final _spine_texture_region_set_original_height = _spine_texture_region_set_original_heightPtr
      .asFunction<void Function(spine_texture_region, int)>();
}

class spine_skeleton_wrapper extends ffi.Opaque {}

class spine_skeleton_data_wrapper extends ffi.Opaque {}

class spine_bone_wrapper extends ffi.Opaque {}

class spine_bone_data_wrapper extends ffi.Opaque {}

class spine_slot_wrapper extends ffi.Opaque {}

class spine_slot_data_wrapper extends ffi.Opaque {}

class spine_skin_wrapper extends ffi.Opaque {}

class spine_attachment_wrapper extends ffi.Opaque {}

class spine_region_attachment_wrapper extends ffi.Opaque {}

class spine_vertex_attachment_wrapper extends ffi.Opaque {}

class spine_mesh_attachment_wrapper extends ffi.Opaque {}

class spine_clipping_attachment_wrapper extends ffi.Opaque {}

class spine_bounding_box_attachment_wrapper extends ffi.Opaque {}

class spine_path_attachment_wrapper extends ffi.Opaque {}

class spine_point_attachment_wrapper extends ffi.Opaque {}

class spine_texture_region_wrapper extends ffi.Opaque {}

class spine_sequence_wrapper extends ffi.Opaque {}

class spine_constraint_wrapper extends ffi.Opaque {}

class spine_constraint_data_wrapper extends ffi.Opaque {}

class spine_ik_constraint_wrapper extends ffi.Opaque {}

class spine_ik_constraint_data_wrapper extends ffi.Opaque {}

class spine_transform_constraint_wrapper extends ffi.Opaque {}

class spine_transform_constraint_data_wrapper extends ffi.Opaque {}

class spine_path_constraint_wrapper extends ffi.Opaque {}

class spine_path_constraint_data_wrapper extends ffi.Opaque {}

class spine_physics_constraint_wrapper extends ffi.Opaque {}

class spine_physics_constraint_data_wrapper extends ffi.Opaque {}

class spine_animation_state_wrapper extends ffi.Opaque {}

class spine_animation_state_data_wrapper extends ffi.Opaque {}

class spine_animation_state_events_wrapper extends ffi.Opaque {}

class spine_event_wrapper extends ffi.Opaque {}

class spine_event_data_wrapper extends ffi.Opaque {}

class spine_track_entry_wrapper extends ffi.Opaque {}

class spine_animation_wrapper extends ffi.Opaque {}

class spine_atlas_wrapper extends ffi.Opaque {}

class spine_skeleton_data_result_wrapper extends ffi.Opaque {}

class spine_render_command_wrapper extends ffi.Opaque {}

class spine_bounds_wrapper extends ffi.Opaque {}

class spine_color_wrapper extends ffi.Opaque {}

class spine_vector_wrapper extends ffi.Opaque {}

class spine_skeleton_drawable_wrapper extends ffi.Opaque {}

class spine_skin_entry_wrapper extends ffi.Opaque {}

class spine_skin_entries_wrapper extends ffi.Opaque {}

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_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_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_COMPLETE = 3;
  static const int SPINE_EVENT_TYPE_DISPOSE = 4;
  static const int SPINE_EVENT_TYPE_EVENT = 5;
}

abstract class spine_attachment_type {
  static const int SPINE_ATTACHMENT_REGION = 0;
  static const int SPINE_ATTACHMENT_MESH = 1;
  static const int SPINE_ATTACHMENT_CLIPPING = 2;
  static const int SPINE_ATTACHMENT_BOUNDING_BOX = 3;
  static const int SPINE_ATTACHMENT_PATH = 4;
  static const int SPINE_ATTACHMENT_POINT = 5;
}

abstract class spine_constraint_type {
  static const int SPINE_CONSTRAINT_IK = 0;
  static const int SPINE_CONSTRAINT_TRANSFORM = 1;
  static const int SPINE_CONSTRAINT_PATH = 2;
}

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_position_mode {
  static const int SPINE_POSITION_MODE_FIXED = 0;
  static const int SPINE_POSITION_MODE_PERCENT = 1;
}

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_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_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;
}

typedef spine_bool = ffi.Int32;
typedef Dartspine_bool = int;
typedef spine_color = ffi.Pointer<spine_color_wrapper>;
typedef spine_bounds = ffi.Pointer<spine_bounds_wrapper>;
typedef spine_vector = ffi.Pointer<spine_vector_wrapper>;
typedef spine_atlas = ffi.Pointer<spine_atlas_wrapper>;
typedef utf8 = ffi.Char;
typedef Dartutf8 = int;
typedef spine_skeleton_data_result = ffi.Pointer<spine_skeleton_data_result_wrapper>;
typedef spine_skeleton_data = ffi.Pointer<spine_skeleton_data_wrapper>;
typedef spine_bone_data = ffi.Pointer<spine_bone_data_wrapper>;
typedef spine_slot_data = ffi.Pointer<spine_slot_data_wrapper>;
typedef spine_skin = ffi.Pointer<spine_skin_wrapper>;
typedef spine_event_data = ffi.Pointer<spine_event_data_wrapper>;
typedef spine_animation = ffi.Pointer<spine_animation_wrapper>;
typedef spine_ik_constraint_data = ffi.Pointer<spine_ik_constraint_data_wrapper>;
typedef spine_transform_constraint_data = ffi.Pointer<spine_transform_constraint_data_wrapper>;
typedef spine_path_constraint_data = ffi.Pointer<spine_path_constraint_data_wrapper>;
typedef spine_physics_constraint_data = ffi.Pointer<spine_physics_constraint_data_wrapper>;
typedef spine_skeleton_drawable = ffi.Pointer<spine_skeleton_drawable_wrapper>;
typedef spine_render_command = ffi.Pointer<spine_render_command_wrapper>;
typedef spine_skeleton = ffi.Pointer<spine_skeleton_wrapper>;
typedef spine_animation_state = ffi.Pointer<spine_animation_state_wrapper>;
typedef spine_animation_state_data = ffi.Pointer<spine_animation_state_data_wrapper>;
typedef spine_animation_state_events = ffi.Pointer<spine_animation_state_events_wrapper>;
typedef spine_track_entry = ffi.Pointer<spine_track_entry_wrapper>;
typedef spine_event = ffi.Pointer<spine_event_wrapper>;
typedef spine_bone = ffi.Pointer<spine_bone_wrapper>;
typedef spine_slot = ffi.Pointer<spine_slot_wrapper>;
typedef spine_attachment = ffi.Pointer<spine_attachment_wrapper>;
typedef spine_ik_constraint = ffi.Pointer<spine_ik_constraint_wrapper>;
typedef spine_transform_constraint = ffi.Pointer<spine_transform_constraint_wrapper>;
typedef spine_path_constraint = ffi.Pointer<spine_path_constraint_wrapper>;
typedef spine_physics_constraint = ffi.Pointer<spine_physics_constraint_wrapper>;
typedef spine_point_attachment = ffi.Pointer<spine_point_attachment_wrapper>;
typedef spine_region_attachment = ffi.Pointer<spine_region_attachment_wrapper>;
typedef spine_texture_region = ffi.Pointer<spine_texture_region_wrapper>;
typedef spine_sequence = ffi.Pointer<spine_sequence_wrapper>;
typedef spine_vertex_attachment = ffi.Pointer<spine_vertex_attachment_wrapper>;
typedef spine_mesh_attachment = ffi.Pointer<spine_mesh_attachment_wrapper>;
typedef spine_clipping_attachment = ffi.Pointer<spine_clipping_attachment_wrapper>;
typedef spine_bounding_box_attachment = ffi.Pointer<spine_bounding_box_attachment_wrapper>;
typedef spine_path_attachment = ffi.Pointer<spine_path_attachment_wrapper>;
typedef spine_skin_entries = ffi.Pointer<spine_skin_entries_wrapper>;
typedef spine_skin_entry = ffi.Pointer<spine_skin_entry_wrapper>;
typedef spine_constraint_data = ffi.Pointer<spine_constraint_data_wrapper>;