// ignore_for_file: always_specify_types
// ignore_for_file: camel_case_types
// ignore_for_file: non_constant_identifier_names

// AUTO GENERATED FILE, DO NOT EDIT.
//
// Generated by `package:ffigen`.
import 'dart:ffi' 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_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()>();

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

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

  void spine_atlas_dispose(
    ffi.Pointer<spine_atlas> atlas,
  ) {
    return _spine_atlas_dispose(
      atlas,
    );
  }

  late final _spine_atlas_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<spine_atlas>)>>(
          'spine_atlas_dispose');
  late final _spine_atlas_dispose = _spine_atlas_disposePtr
      .asFunction<void Function(ffi.Pointer<spine_atlas>)>();

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

  late final _spine_skeleton_data_load_jsonPtr = _lookup<
      ffi.NativeFunction<
          spine_skeleton_data_result Function(ffi.Pointer<spine_atlas>,
              ffi.Pointer<ffi.Int8>)>>('spine_skeleton_data_load_json');
  late final _spine_skeleton_data_load_json =
      _spine_skeleton_data_load_jsonPtr.asFunction<
          spine_skeleton_data_result Function(
              ffi.Pointer<spine_atlas>, ffi.Pointer<ffi.Int8>)>();

  spine_skeleton_data_result spine_skeleton_data_load_binary(
    ffi.Pointer<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(
              ffi.Pointer<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(
              ffi.Pointer<spine_atlas>, ffi.Pointer<ffi.Uint8>, int)>();

  void spine_skeleton_data_dispose(
    spine_skeleton_data skeletonData,
  ) {
    return _spine_skeleton_data_dispose(
      skeletonData,
    );
  }

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

  ffi.Pointer<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<
          ffi.Pointer<spine_skeleton_drawable> Function(
              spine_skeleton_data)>>('spine_skeleton_drawable_create');
  late final _spine_skeleton_drawable_create =
      _spine_skeleton_drawable_createPtr.asFunction<
          ffi.Pointer<spine_skeleton_drawable> Function(spine_skeleton_data)>();

  ffi.Pointer<spine_render_command> spine_skeleton_drawable_render(
    ffi.Pointer<spine_skeleton_drawable> drawable,
  ) {
    return _spine_skeleton_drawable_render(
      drawable,
    );
  }

  late final _spine_skeleton_drawable_renderPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<spine_render_command> Function(
                  ffi.Pointer<spine_skeleton_drawable>)>>(
      'spine_skeleton_drawable_render');
  late final _spine_skeleton_drawable_render =
      _spine_skeleton_drawable_renderPtr.asFunction<
          ffi.Pointer<spine_render_command> Function(
              ffi.Pointer<spine_skeleton_drawable>)>();

  void spine_skeleton_drawable_dispose(
    ffi.Pointer<spine_skeleton_drawable> drawable,
  ) {
    return _spine_skeleton_drawable_dispose(
      drawable,
    );
  }

  late final _spine_skeleton_drawable_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Pointer<spine_skeleton_drawable>)>>(
      'spine_skeleton_drawable_dispose');
  late final _spine_skeleton_drawable_dispose =
      _spine_skeleton_drawable_disposePtr
          .asFunction<void Function(ffi.Pointer<spine_skeleton_drawable>)>();

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

  spine_track_entry spine_animation_state_set_animation(
    spine_animation_state state,
    int trackIndex,
    ffi.Pointer<ffi.Int8> animationName,
    int loop,
  ) {
    return _spine_animation_state_set_animation(
      state,
      trackIndex,
      animationName,
      loop,
    );
  }

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

  spine_track_entry spine_animation_state_add_animation(
    spine_animation_state state,
    int trackIndex,
    ffi.Pointer<ffi.Int8> animationName,
    int loop,
    double delay,
  ) {
    return _spine_animation_state_add_animation(
      state,
      trackIndex,
      animationName,
      loop,
      delay,
    );
  }

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

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

  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<ffi.Int32 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, ffi.Int32)>>(
      '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<ffi.Int32 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, ffi.Int32)>>(
      '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<ffi.Int32 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, ffi.Int32)>>(
      '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<ffi.Int32 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, ffi.Int32)>>(
      '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_attachment_threshold(
    spine_track_entry entry,
  ) {
    return _spine_track_entry_get_attachment_threshold(
      entry,
    );
  }

  late final _spine_track_entry_get_attachment_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_attachment_threshold');
  late final _spine_track_entry_get_attachment_threshold =
      _spine_track_entry_get_attachment_thresholdPtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_attachment_threshold(
    spine_track_entry entry,
    double attachmentThreshold,
  ) {
    return _spine_track_entry_set_attachment_threshold(
      entry,
      attachmentThreshold,
    );
  }

  late final _spine_track_entry_set_attachment_thresholdPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_attachment_threshold');
  late final _spine_track_entry_set_attachment_threshold =
      _spine_track_entry_set_attachment_thresholdPtr
          .asFunction<void Function(spine_track_entry, double)>();

  double spine_track_entry_get_draw_order_threshold(
    spine_track_entry entry,
  ) {
    return _spine_track_entry_get_draw_order_threshold(
      entry,
    );
  }

  late final _spine_track_entry_get_draw_order_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_draw_order_threshold');
  late final _spine_track_entry_get_draw_order_threshold =
      _spine_track_entry_get_draw_order_thresholdPtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_draw_order_threshold(
    spine_track_entry entry,
    double drawOrderThreshold,
  ) {
    return _spine_track_entry_set_draw_order_threshold(
      entry,
      drawOrderThreshold,
    );
  }

  late final _spine_track_entry_set_draw_order_thresholdPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_draw_order_threshold');
  late final _spine_track_entry_set_draw_order_threshold =
      _spine_track_entry_set_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<ffi.Int32 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)>();

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

  void spine_skeleton_update_world_transform(
    spine_skeleton skeleton,
  ) {
    return _spine_skeleton_update_world_transform(
      skeleton,
    );
  }

  late final _spine_skeleton_update_world_transformPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
          'spine_skeleton_update_world_transform');
  late final _spine_skeleton_update_world_transform =
      _spine_skeleton_update_world_transformPtr
          .asFunction<void Function(spine_skeleton)>();

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

  late final _spine_skeleton_update_world_transform_bonePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_skeleton, 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, 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<ffi.Int8> boneName,
  ) {
    return _spine_skeleton_find_bone(
      skeleton,
      boneName,
    );
  }

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

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

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

  void spine_skeleton_set_skin_by_name(
    spine_skeleton skeleton,
    ffi.Pointer<ffi.Int8> 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<ffi.Int8>)>>('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<ffi.Int8>)>();

  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<ffi.Int8> slotName,
    ffi.Pointer<ffi.Int8> 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<ffi.Int8>,
              ffi.Pointer<ffi.Int8>)>>('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<ffi.Int8>, ffi.Pointer<ffi.Int8>)>();

  spine_attachment spine_skeleton_get_attachment(
    spine_skeleton skeleton,
    int slotIndex,
    ffi.Pointer<ffi.Int8> 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<ffi.Int8>)>>('spine_skeleton_get_attachment');
  late final _spine_skeleton_get_attachment =
      _spine_skeleton_get_attachmentPtr.asFunction<
          spine_attachment Function(
              spine_skeleton, int, ffi.Pointer<ffi.Int8>)>();

  void spine_skeleton_set_attachment(
    spine_skeleton skeleton,
    ffi.Pointer<ffi.Int8> slotName,
    ffi.Pointer<ffi.Int8> 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<ffi.Int8>,
              ffi.Pointer<ffi.Int8>)>>('spine_skeleton_set_attachment');
  late final _spine_skeleton_set_attachment =
      _spine_skeleton_set_attachmentPtr.asFunction<
          void Function(
              spine_skeleton, ffi.Pointer<ffi.Int8>, ffi.Pointer<ffi.Int8>)>();

  spine_ik_constraint spine_skeleton_find_ik_constraint(
    spine_skeleton skeleton,
    ffi.Pointer<ffi.Int8> 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<ffi.Int8>)>>('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<ffi.Int8>)>();

  spine_transform_constraint spine_skeleton_find_transform_constraint(
    spine_skeleton skeleton,
    ffi.Pointer<ffi.Int8> 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<ffi.Int8>)>>(
      '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<ffi.Int8>)>();

  spine_path_constraint spine_skeleton_find_path_constraint(
    spine_skeleton skeleton,
    ffi.Pointer<ffi.Int8> 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<ffi.Int8>)>>('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<ffi.Int8>)>();

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

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

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

class spine_atlas extends ffi.Struct {
  external ffi.Pointer<ffi.Void> atlas;

  external ffi.Pointer<ffi.Pointer<ffi.Int8>> imagePaths;

  @ffi.Int32()
  external int numImagePaths;

  external ffi.Pointer<ffi.Int8> error;
}

class spine_skeleton_data_result extends ffi.Struct {
  external spine_skeleton_data skeletonData;

  external ffi.Pointer<ffi.Int8> error;
}

typedef spine_skeleton_data = ffi.Pointer<ffi.Void>;

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

class spine_render_command extends ffi.Struct {
  external ffi.Pointer<ffi.Float> positions;

  external ffi.Pointer<ffi.Float> uvs;

  external ffi.Pointer<ffi.Int32> colors;

  @ffi.Int32()
  external int numVertices;

  external ffi.Pointer<ffi.Uint16> indices;

  @ffi.Int32()
  external int numIndices;

  @ffi.Int32()
  external int atlasPage;

  @ffi.Int32()
  external int blendMode;

  external ffi.Pointer<spine_render_command> next;
}

class spine_bounds extends ffi.Struct {
  @ffi.Float()
  external double x;

  @ffi.Float()
  external double y;

  @ffi.Float()
  external double width;

  @ffi.Float()
  external double height;
}

class spine_color extends ffi.Struct {
  @ffi.Float()
  external double r;

  @ffi.Float()
  external double g;

  @ffi.Float()
  external double b;

  @ffi.Float()
  external double a;
}

class spine_skeleton_drawable extends ffi.Struct {
  external spine_skeleton skeleton;

  external spine_animation_state animationState;

  external spine_animation_state_events animationStateEvents;

  external ffi.Pointer<ffi.Void> clipping;

  external ffi.Pointer<spine_render_command> renderCommand;
}

typedef spine_skeleton = ffi.Pointer<ffi.Void>;
typedef spine_animation_state = ffi.Pointer<ffi.Void>;
typedef spine_animation_state_events = ffi.Pointer<ffi.Void>;
typedef spine_track_entry = ffi.Pointer<ffi.Void>;
typedef spine_event = ffi.Pointer<ffi.Void>;
typedef spine_animation = ffi.Pointer<ffi.Void>;
typedef spine_bone = ffi.Pointer<ffi.Void>;
typedef spine_slot = ffi.Pointer<ffi.Void>;
typedef spine_skin = ffi.Pointer<ffi.Void>;
typedef spine_attachment = ffi.Pointer<ffi.Void>;
typedef spine_ik_constraint = ffi.Pointer<ffi.Void>;
typedef spine_transform_constraint = ffi.Pointer<ffi.Void>;
typedef spine_path_constraint = ffi.Pointer<ffi.Void>;