// 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>;