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

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

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

/// Bindings for Spine C headers.
///
/// 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;

  /// Version functions
  int spine_major_version() {
    return _spine_major_version();
  }

  late final _spine_major_versionPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function()>>('spine_major_version');
  late final _spine_major_version =
      _spine_major_versionPtr.asFunction<int Function()>();

  int spine_minor_version() {
    return _spine_minor_version();
  }

  late final _spine_minor_versionPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function()>>('spine_minor_version');
  late final _spine_minor_version =
      _spine_minor_versionPtr.asFunction<int Function()>();

  void spine_enable_debug_extension(
    bool enable,
  ) {
    return _spine_enable_debug_extension(
      enable,
    );
  }

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

  void spine_report_leaks() {
    return _spine_report_leaks();
  }

  late final _spine_report_leaksPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>('spine_report_leaks');
  late final _spine_report_leaks =
      _spine_report_leaksPtr.asFunction<void Function()>();

  /// Bounds functions
  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)>();

  /// Vector functions
  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)>();

  /// Atlas functions
  int spine_atlas_load(
    ffi.Pointer<ffi.Char> atlasData,
  ) {
    return _spine_atlas_load(
      atlasData,
    );
  }

  late final _spine_atlas_loadPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Char>)>>(
          'spine_atlas_load');
  late final _spine_atlas_load =
      _spine_atlas_loadPtr.asFunction<int Function(ffi.Pointer<ffi.Char>)>();

  int spine_atlas_load_callback(
    ffi.Pointer<ffi.Char> atlasData,
    ffi.Pointer<ffi.Char> atlasDir,
    spine_texture_loader_load_func load,
    spine_texture_loader_unload_func unload,
  ) {
    return _spine_atlas_load_callback(
      atlasData,
      atlasDir,
      load,
      unload,
    );
  }

  late final _spine_atlas_load_callbackPtr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              spine_texture_loader_load_func,
              spine_texture_loader_unload_func)>>('spine_atlas_load_callback');
  late final _spine_atlas_load_callback =
      _spine_atlas_load_callbackPtr.asFunction<
          int Function(
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              spine_texture_loader_load_func,
              spine_texture_loader_unload_func)>();

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

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

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

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

  bool spine_atlas_is_pma(
    int atlas,
  ) {
    return _spine_atlas_is_pma(
      atlas,
    );
  }

  late final _spine_atlas_is_pmaPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Int)>>(
          'spine_atlas_is_pma');
  late final _spine_atlas_is_pma =
      _spine_atlas_is_pmaPtr.asFunction<bool Function(int)>();

  ffi.Pointer<ffi.Char> spine_atlas_get_error(
    int atlas,
  ) {
    return _spine_atlas_get_error(
      atlas,
    );
  }

  late final _spine_atlas_get_errorPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(ffi.Int)>>(
          'spine_atlas_get_error');
  late final _spine_atlas_get_error = _spine_atlas_get_errorPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(int)>();

  void spine_atlas_dispose(
    int atlas,
  ) {
    return _spine_atlas_dispose(
      atlas,
    );
  }

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

  /// Skeleton data functions
  spine_skeleton_data_result spine_skeleton_data_load_json(
    int atlas,
    ffi.Pointer<ffi.Char> skeletonData,
    ffi.Pointer<ffi.Char> path,
  ) {
    return _spine_skeleton_data_load_json(
      atlas,
      skeletonData,
      path,
    );
  }

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

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

  late final _spine_skeleton_data_load_binaryPtr = _lookup<
      ffi.NativeFunction<
          spine_skeleton_data_result Function(
              ffi.Int,
              ffi.Pointer<ffi.Uint8>,
              ffi.Int32,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_data_load_binary');
  late final _spine_skeleton_data_load_binary =
      _spine_skeleton_data_load_binaryPtr.asFunction<
          spine_skeleton_data_result Function(
              int, ffi.Pointer<ffi.Uint8>, int, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> spine_skeleton_data_result_get_error(
    spine_skeleton_data_result result,
  ) {
    return _spine_skeleton_data_result_get_error(
      result,
    );
  }

  late final _spine_skeleton_data_result_get_errorPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(spine_skeleton_data_result)>>(
      'spine_skeleton_data_result_get_error');
  late final _spine_skeleton_data_result_get_error =
      _spine_skeleton_data_result_get_errorPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(spine_skeleton_data_result)>();

  int 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<ffi.Int 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<int Function(spine_skeleton_data_result)>();

  void spine_skeleton_data_result_dispose(
    spine_skeleton_data_result result,
  ) {
    return _spine_skeleton_data_result_dispose(
      result,
    );
  }

  late final _spine_skeleton_data_result_disposePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_skeleton_data_result)>>(
      'spine_skeleton_data_result_dispose');
  late final _spine_skeleton_data_result_dispose =
      _spine_skeleton_data_result_disposePtr
          .asFunction<void Function(spine_skeleton_data_result)>();

  /// Skeleton drawable functions
  spine_skeleton_drawable spine_skeleton_drawable_create(
    int skeletonData,
  ) {
    return _spine_skeleton_drawable_create(
      skeletonData,
    );
  }

  late final _spine_skeleton_drawable_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_drawable Function(ffi.Int)>>(
          'spine_skeleton_drawable_create');
  late final _spine_skeleton_drawable_create =
      _spine_skeleton_drawable_createPtr
          .asFunction<spine_skeleton_drawable Function(int)>();

  int spine_skeleton_drawable_render(
    spine_skeleton_drawable drawable,
  ) {
    return _spine_skeleton_drawable_render(
      drawable,
    );
  }

  late final _spine_skeleton_drawable_renderPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_skeleton_drawable)>>(
          'spine_skeleton_drawable_render');
  late final _spine_skeleton_drawable_render =
      _spine_skeleton_drawable_renderPtr
          .asFunction<int 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)>();

  int 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<ffi.Int Function(spine_skeleton_drawable)>>(
          'spine_skeleton_drawable_get_skeleton');
  late final _spine_skeleton_drawable_get_skeleton =
      _spine_skeleton_drawable_get_skeletonPtr
          .asFunction<int Function(spine_skeleton_drawable)>();

  int 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<ffi.Int 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<int Function(spine_skeleton_drawable)>();

  int 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<ffi.Int 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<int 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)>();

  /// Skin entries functions
  spine_skin_entries spine_skin_entries_create() {
    return _spine_skin_entries_create();
  }

  late final _spine_skin_entries_createPtr =
      _lookup<ffi.NativeFunction<spine_skin_entries Function()>>(
          'spine_skin_entries_create');
  late final _spine_skin_entries_create =
      _spine_skin_entries_createPtr.asFunction<spine_skin_entries Function()>();

  void spine_skin_entries_dispose(
    spine_skin_entries entries,
  ) {
    return _spine_skin_entries_dispose(
      entries,
    );
  }

  late final _spine_skin_entries_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin_entries)>>(
          'spine_skin_entries_dispose');
  late final _spine_skin_entries_dispose = _spine_skin_entries_disposePtr
      .asFunction<void Function(spine_skin_entries)>();

  int spine_skin_entries_get_num_entries(
    spine_skin_entries entries,
  ) {
    return _spine_skin_entries_get_num_entries(
      entries,
    );
  }

  late final _spine_skin_entries_get_num_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skin_entries)>>(
          'spine_skin_entries_get_num_entries');
  late final _spine_skin_entries_get_num_entries =
      _spine_skin_entries_get_num_entriesPtr
          .asFunction<int Function(spine_skin_entries)>();

  spine_skin_entry spine_skin_entries_get_entry(
    spine_skin_entries entries,
    int index,
  ) {
    return _spine_skin_entries_get_entry(
      entries,
      index,
    );
  }

  late final _spine_skin_entries_get_entryPtr = _lookup<
      ffi.NativeFunction<
          spine_skin_entry Function(
              spine_skin_entries, ffi.Int32)>>('spine_skin_entries_get_entry');
  late final _spine_skin_entries_get_entry = _spine_skin_entries_get_entryPtr
      .asFunction<spine_skin_entry Function(spine_skin_entries, int)>();

  /// Skin entry functions
  int spine_skin_entry_get_slot_index(
    spine_skin_entry entry,
  ) {
    return _spine_skin_entry_get_slot_index(
      entry,
    );
  }

  late final _spine_skin_entry_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skin_entry)>>(
          'spine_skin_entry_get_slot_index');
  late final _spine_skin_entry_get_slot_index =
      _spine_skin_entry_get_slot_indexPtr
          .asFunction<int Function(spine_skin_entry)>();

  ffi.Pointer<ffi.Char> spine_skin_entry_get_name(
    spine_skin_entry entry,
  ) {
    return _spine_skin_entry_get_name(
      entry,
    );
  }

  late final _spine_skin_entry_get_namePtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skin_entry)>>(
      'spine_skin_entry_get_name');
  late final _spine_skin_entry_get_name = _spine_skin_entry_get_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_skin_entry)>();

  int 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<ffi.Int Function(spine_skin_entry)>>(
          'spine_skin_entry_get_attachment');
  late final _spine_skin_entry_get_attachment =
      _spine_skin_entry_get_attachmentPtr
          .asFunction<int Function(spine_skin_entry)>();

  spine_array_float spine_array_float_create() {
    return _spine_array_float_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_int spine_array_int_create() {
    return _spine_array_int_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_unsigned_short spine_array_unsigned_short_create() {
    return _spine_array_unsigned_short_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_property_id spine_array_property_id_create() {
    return _spine_array_property_id_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_animation spine_array_animation_create() {
    return _spine_array_animation_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_atlas_page spine_array_atlas_page_create() {
    return _spine_array_atlas_page_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_atlas_region spine_array_atlas_region_create() {
    return _spine_array_atlas_region_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_attachment spine_array_attachment_create() {
    return _spine_array_attachment_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_bone spine_array_bone_create() {
    return _spine_array_bone_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_bone_data spine_array_bone_data_create() {
    return _spine_array_bone_data_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_bone_pose spine_array_bone_pose_create() {
    return _spine_array_bone_pose_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_bounding_box_attachment
      spine_array_bounding_box_attachment_create() {
    return _spine_array_bounding_box_attachment_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_constraint spine_array_constraint_create() {
    return _spine_array_constraint_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_constraint_data spine_array_constraint_data_create() {
    return _spine_array_constraint_data_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_event spine_array_event_create() {
    return _spine_array_event_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_event_data spine_array_event_data_create() {
    return _spine_array_event_data_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_from_property spine_array_from_property_create() {
    return _spine_array_from_property_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_physics_constraint spine_array_physics_constraint_create() {
    return _spine_array_physics_constraint_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_polygon spine_array_polygon_create() {
    return _spine_array_polygon_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_skin spine_array_skin_create() {
    return _spine_array_skin_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_slot spine_array_slot_create() {
    return _spine_array_slot_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_slot_data spine_array_slot_data_create() {
    return _spine_array_slot_data_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_texture_region spine_array_texture_region_create() {
    return _spine_array_texture_region_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_timeline spine_array_timeline_create() {
    return _spine_array_timeline_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_to_property spine_array_to_property_create() {
    return _spine_array_to_property_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_track_entry spine_array_track_entry_create() {
    return _spine_array_track_entry_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_array_update spine_array_update_create() {
    return _spine_array_update_create();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  spine_alpha_timeline spine_alpha_timeline_create(
    int frameCount,
    int bezierCount,
    int slotIndex,
  ) {
    return _spine_alpha_timeline_create(
      frameCount,
      bezierCount,
      slotIndex,
    );
  }

  late final _spine_alpha_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_alpha_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_alpha_timeline_create');
  late final _spine_alpha_timeline_create = _spine_alpha_timeline_createPtr
      .asFunction<spine_alpha_timeline Function(int, int, int)>();

  void spine_alpha_timeline_dispose(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_dispose(
      self,
    );
  }

  late final _spine_alpha_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_alpha_timeline)>>(
          'spine_alpha_timeline_dispose');
  late final _spine_alpha_timeline_dispose = _spine_alpha_timeline_disposePtr
      .asFunction<void Function(spine_alpha_timeline)>();

  spine_rtti spine_alpha_timeline_get_rtti(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_rtti(
      self,
    );
  }

  late final _spine_alpha_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_alpha_timeline)>>(
          'spine_alpha_timeline_get_rtti');
  late final _spine_alpha_timeline_get_rtti = _spine_alpha_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_alpha_timeline)>();

  void spine_alpha_timeline_apply(
    spine_alpha_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_alpha_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_alpha_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_alpha_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_alpha_timeline_apply');
  late final _spine_alpha_timeline_apply =
      _spine_alpha_timeline_applyPtr.asFunction<
          void Function(spine_alpha_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_alpha_timeline_set_frame(
    spine_alpha_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_alpha_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_alpha_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_alpha_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_alpha_timeline_set_frame');
  late final _spine_alpha_timeline_set_frame =
      _spine_alpha_timeline_set_framePtr.asFunction<
          void Function(spine_alpha_timeline, int, double, double)>();

  double spine_alpha_timeline_get_curve_value(
    spine_alpha_timeline self,
    double time,
  ) {
    return _spine_alpha_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_alpha_timeline_get_curve_valuePtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_alpha_timeline, ffi.Float)>>(
      'spine_alpha_timeline_get_curve_value');
  late final _spine_alpha_timeline_get_curve_value =
      _spine_alpha_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_alpha_timeline, double)>();

  double spine_alpha_timeline_get_relative_value(
    spine_alpha_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_alpha_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_alpha_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_alpha_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_alpha_timeline_get_relative_value');
  late final _spine_alpha_timeline_get_relative_value =
      _spine_alpha_timeline_get_relative_valuePtr.asFunction<
          double Function(
              spine_alpha_timeline, double, double, int, double, double)>();

  double spine_alpha_timeline_get_absolute_value_1(
    spine_alpha_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_alpha_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_alpha_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_alpha_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_alpha_timeline_get_absolute_value_1');
  late final _spine_alpha_timeline_get_absolute_value_1 =
      _spine_alpha_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(
              spine_alpha_timeline, double, double, int, double, double)>();

  double spine_alpha_timeline_get_absolute_value_2(
    spine_alpha_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_alpha_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_alpha_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_alpha_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_alpha_timeline_get_absolute_value_2');
  late final _spine_alpha_timeline_get_absolute_value_2 =
      _spine_alpha_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_alpha_timeline, double, double, int, double,
              double, double)>();

  double spine_alpha_timeline_get_scale_value(
    spine_alpha_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_alpha_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_alpha_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_alpha_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_alpha_timeline_get_scale_value');
  late final _spine_alpha_timeline_get_scale_value =
      _spine_alpha_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_alpha_timeline, double, double, int, int,
              double, double)>();

  void spine_alpha_timeline_set_linear(
    spine_alpha_timeline self,
    int frame,
  ) {
    return _spine_alpha_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_alpha_timeline_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_alpha_timeline, ffi.Size)>>(
      'spine_alpha_timeline_set_linear');
  late final _spine_alpha_timeline_set_linear =
      _spine_alpha_timeline_set_linearPtr
          .asFunction<void Function(spine_alpha_timeline, int)>();

  void spine_alpha_timeline_set_stepped(
    spine_alpha_timeline self,
    int frame,
  ) {
    return _spine_alpha_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_alpha_timeline_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_alpha_timeline, ffi.Size)>>(
      'spine_alpha_timeline_set_stepped');
  late final _spine_alpha_timeline_set_stepped =
      _spine_alpha_timeline_set_steppedPtr
          .asFunction<void Function(spine_alpha_timeline, int)>();

  void spine_alpha_timeline_set_bezier(
    spine_alpha_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_alpha_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_alpha_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_alpha_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_alpha_timeline_set_bezier');
  late final _spine_alpha_timeline_set_bezier =
      _spine_alpha_timeline_set_bezierPtr.asFunction<
          void Function(spine_alpha_timeline, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_alpha_timeline_get_bezier_value(
    spine_alpha_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_alpha_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_alpha_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_alpha_timeline, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_alpha_timeline_get_bezier_value');
  late final _spine_alpha_timeline_get_bezier_value =
      _spine_alpha_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_alpha_timeline, double, int, int, int)>();

  spine_array_float spine_alpha_timeline_get_curves(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_curves(
      self,
    );
  }

  late final _spine_alpha_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_alpha_timeline)>>(
      'spine_alpha_timeline_get_curves');
  late final _spine_alpha_timeline_get_curves =
      _spine_alpha_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_alpha_timeline)>();

  int spine_alpha_timeline_get_frame_entries(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_alpha_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_alpha_timeline)>>(
          'spine_alpha_timeline_get_frame_entries');
  late final _spine_alpha_timeline_get_frame_entries =
      _spine_alpha_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_alpha_timeline)>();

  int spine_alpha_timeline_get_frame_count(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_alpha_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_alpha_timeline)>>(
          'spine_alpha_timeline_get_frame_count');
  late final _spine_alpha_timeline_get_frame_count =
      _spine_alpha_timeline_get_frame_countPtr
          .asFunction<int Function(spine_alpha_timeline)>();

  spine_array_float spine_alpha_timeline_get_frames(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_frames(
      self,
    );
  }

  late final _spine_alpha_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_alpha_timeline)>>(
      'spine_alpha_timeline_get_frames');
  late final _spine_alpha_timeline_get_frames =
      _spine_alpha_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_alpha_timeline)>();

  double spine_alpha_timeline_get_duration(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_duration(
      self,
    );
  }

  late final _spine_alpha_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_alpha_timeline)>>(
          'spine_alpha_timeline_get_duration');
  late final _spine_alpha_timeline_get_duration =
      _spine_alpha_timeline_get_durationPtr
          .asFunction<double Function(spine_alpha_timeline)>();

  spine_array_property_id spine_alpha_timeline_get_property_ids(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_alpha_timeline_get_property_idsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_property_id Function(
              spine_alpha_timeline)>>('spine_alpha_timeline_get_property_ids');
  late final _spine_alpha_timeline_get_property_ids =
      _spine_alpha_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_alpha_timeline)>();

  int spine_alpha_timeline_get_slot_index(
    spine_alpha_timeline self,
  ) {
    return _spine_alpha_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_alpha_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_alpha_timeline)>>(
          'spine_alpha_timeline_get_slot_index');
  late final _spine_alpha_timeline_get_slot_index =
      _spine_alpha_timeline_get_slot_indexPtr
          .asFunction<int Function(spine_alpha_timeline)>();

  void spine_alpha_timeline_set_slot_index(
    spine_alpha_timeline self,
    int inValue,
  ) {
    return _spine_alpha_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_alpha_timeline_set_slot_indexPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_alpha_timeline, ffi.Int)>>(
      'spine_alpha_timeline_set_slot_index');
  late final _spine_alpha_timeline_set_slot_index =
      _spine_alpha_timeline_set_slot_indexPtr
          .asFunction<void Function(spine_alpha_timeline, int)>();

  spine_rtti spine_alpha_timeline_rtti() {
    return _spine_alpha_timeline_rtti();
  }

  late final _spine_alpha_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_alpha_timeline_rtti');
  late final _spine_alpha_timeline_rtti =
      _spine_alpha_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_animation spine_animation_create(
    ffi.Pointer<ffi.Char> name,
    spine_array_timeline timelines,
    double duration,
  ) {
    return _spine_animation_create(
      name,
      timelines,
      duration,
    );
  }

  late final _spine_animation_createPtr = _lookup<
      ffi.NativeFunction<
          spine_animation Function(ffi.Pointer<ffi.Char>, spine_array_timeline,
              ffi.Float)>>('spine_animation_create');
  late final _spine_animation_create = _spine_animation_createPtr.asFunction<
      spine_animation Function(
          ffi.Pointer<ffi.Char>, spine_array_timeline, double)>();

  void spine_animation_dispose(
    spine_animation self,
  ) {
    return _spine_animation_dispose(
      self,
    );
  }

  late final _spine_animation_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation)>>(
          'spine_animation_dispose');
  late final _spine_animation_dispose =
      _spine_animation_disposePtr.asFunction<void Function(spine_animation)>();

  spine_array_timeline spine_animation_get_timelines(
    spine_animation self,
  ) {
    return _spine_animation_get_timelines(
      self,
    );
  }

  late final _spine_animation_get_timelinesPtr = _lookup<
          ffi.NativeFunction<spine_array_timeline Function(spine_animation)>>(
      'spine_animation_get_timelines');
  late final _spine_animation_get_timelines = _spine_animation_get_timelinesPtr
      .asFunction<spine_array_timeline Function(spine_animation)>();

  void spine_animation_set_timelines(
    spine_animation self,
    spine_array_timeline timelines,
  ) {
    return _spine_animation_set_timelines(
      self,
      timelines,
    );
  }

  late final _spine_animation_set_timelinesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_animation,
              spine_array_timeline)>>('spine_animation_set_timelines');
  late final _spine_animation_set_timelines = _spine_animation_set_timelinesPtr
      .asFunction<void Function(spine_animation, spine_array_timeline)>();

  bool spine_animation_has_timeline(
    spine_animation self,
    spine_array_property_id ids,
  ) {
    return _spine_animation_has_timeline(
      self,
      ids,
    );
  }

  late final _spine_animation_has_timelinePtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(spine_animation,
              spine_array_property_id)>>('spine_animation_has_timeline');
  late final _spine_animation_has_timeline = _spine_animation_has_timelinePtr
      .asFunction<bool Function(spine_animation, spine_array_property_id)>();

  double spine_animation_get_duration(
    spine_animation self,
  ) {
    return _spine_animation_get_duration(
      self,
    );
  }

  late final _spine_animation_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_animation)>>(
          'spine_animation_get_duration');
  late final _spine_animation_get_duration = _spine_animation_get_durationPtr
      .asFunction<double Function(spine_animation)>();

  void spine_animation_set_duration(
    spine_animation self,
    double inValue,
  ) {
    return _spine_animation_set_duration(
      self,
      inValue,
    );
  }

  late final _spine_animation_set_durationPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_animation, ffi.Float)>>(
      'spine_animation_set_duration');
  late final _spine_animation_set_duration = _spine_animation_set_durationPtr
      .asFunction<void Function(spine_animation, double)>();

  void spine_animation_apply(
    spine_animation self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    bool loop,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_animation_apply(
      self,
      skeleton,
      lastTime,
      time,
      loop,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_animation_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_animation,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              ffi.Bool,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_animation_apply');
  late final _spine_animation_apply = _spine_animation_applyPtr.asFunction<
      void Function(spine_animation, spine_skeleton, double, double, bool,
          spine_array_event, double, int, int, bool)>();

  ffi.Pointer<ffi.Char> spine_animation_get_name(
    spine_animation self,
  ) {
    return _spine_animation_get_name(
      self,
    );
  }

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

  spine_array_int spine_animation_get_bones(
    spine_animation self,
  ) {
    return _spine_animation_get_bones(
      self,
    );
  }

  late final _spine_animation_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_int Function(spine_animation)>>(
          'spine_animation_get_bones');
  late final _spine_animation_get_bones = _spine_animation_get_bonesPtr
      .asFunction<spine_array_int Function(spine_animation)>();

  int spine_animation_search_1(
    spine_array_float values,
    double target,
  ) {
    return _spine_animation_search_1(
      values,
      target,
    );
  }

  late final _spine_animation_search_1Ptr = _lookup<
          ffi.NativeFunction<ffi.Int Function(spine_array_float, ffi.Float)>>(
      'spine_animation_search_1');
  late final _spine_animation_search_1 = _spine_animation_search_1Ptr
      .asFunction<int Function(spine_array_float, double)>();

  int spine_animation_search_2(
    spine_array_float values,
    double target,
    int step,
  ) {
    return _spine_animation_search_2(
      values,
      target,
      step,
    );
  }

  late final _spine_animation_search_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Int Function(spine_array_float, ffi.Float,
              ffi.Int)>>('spine_animation_search_2');
  late final _spine_animation_search_2 = _spine_animation_search_2Ptr
      .asFunction<int Function(spine_array_float, double, int)>();

  spine_animation_state spine_animation_state_create(
    spine_animation_state_data data,
  ) {
    return _spine_animation_state_create(
      data,
    );
  }

  late final _spine_animation_state_createPtr = _lookup<
      ffi.NativeFunction<
          spine_animation_state Function(
              spine_animation_state_data)>>('spine_animation_state_create');
  late final _spine_animation_state_create = _spine_animation_state_createPtr
      .asFunction<spine_animation_state Function(spine_animation_state_data)>();

  void spine_animation_state_dispose(
    spine_animation_state self,
  ) {
    return _spine_animation_state_dispose(
      self,
    );
  }

  late final _spine_animation_state_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state)>>(
          'spine_animation_state_dispose');
  late final _spine_animation_state_dispose = _spine_animation_state_disposePtr
      .asFunction<void Function(spine_animation_state)>();

  void spine_animation_state_update(
    spine_animation_state self,
    double delta,
  ) {
    return _spine_animation_state_update(
      self,
      delta,
    );
  }

  late final _spine_animation_state_updatePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_animation_state, ffi.Float)>>(
      'spine_animation_state_update');
  late final _spine_animation_state_update = _spine_animation_state_updatePtr
      .asFunction<void Function(spine_animation_state, double)>();

  bool spine_animation_state_apply(
    spine_animation_state self,
    spine_skeleton skeleton,
  ) {
    return _spine_animation_state_apply(
      self,
      skeleton,
    );
  }

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

  void spine_animation_state_clear_tracks(
    spine_animation_state self,
  ) {
    return _spine_animation_state_clear_tracks(
      self,
    );
  }

  late final _spine_animation_state_clear_tracksPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state)>>(
          'spine_animation_state_clear_tracks');
  late final _spine_animation_state_clear_tracks =
      _spine_animation_state_clear_tracksPtr
          .asFunction<void Function(spine_animation_state)>();

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

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

  spine_track_entry spine_animation_state_set_animation_1(
    spine_animation_state self,
    int trackIndex,
    ffi.Pointer<ffi.Char> animationName,
    bool loop,
  ) {
    return _spine_animation_state_set_animation_1(
      self,
      trackIndex,
      animationName,
      loop,
    );
  }

  late final _spine_animation_state_set_animation_1Ptr = _lookup<
      ffi.NativeFunction<
          spine_track_entry Function(
              spine_animation_state,
              ffi.Size,
              ffi.Pointer<ffi.Char>,
              ffi.Bool)>>('spine_animation_state_set_animation_1');
  late final _spine_animation_state_set_animation_1 =
      _spine_animation_state_set_animation_1Ptr.asFunction<
          spine_track_entry Function(
              spine_animation_state, int, ffi.Pointer<ffi.Char>, bool)>();

  spine_track_entry spine_animation_state_set_animation_2(
    spine_animation_state self,
    int trackIndex,
    spine_animation animation,
    bool loop,
  ) {
    return _spine_animation_state_set_animation_2(
      self,
      trackIndex,
      animation,
      loop,
    );
  }

  late final _spine_animation_state_set_animation_2Ptr = _lookup<
      ffi.NativeFunction<
          spine_track_entry Function(
              spine_animation_state,
              ffi.Size,
              spine_animation,
              ffi.Bool)>>('spine_animation_state_set_animation_2');
  late final _spine_animation_state_set_animation_2 =
      _spine_animation_state_set_animation_2Ptr.asFunction<
          spine_track_entry Function(
              spine_animation_state, int, spine_animation, bool)>();

  spine_track_entry spine_animation_state_add_animation_1(
    spine_animation_state self,
    int trackIndex,
    ffi.Pointer<ffi.Char> animationName,
    bool loop,
    double delay,
  ) {
    return _spine_animation_state_add_animation_1(
      self,
      trackIndex,
      animationName,
      loop,
      delay,
    );
  }

  late final _spine_animation_state_add_animation_1Ptr = _lookup<
      ffi.NativeFunction<
          spine_track_entry Function(
              spine_animation_state,
              ffi.Size,
              ffi.Pointer<ffi.Char>,
              ffi.Bool,
              ffi.Float)>>('spine_animation_state_add_animation_1');
  late final _spine_animation_state_add_animation_1 =
      _spine_animation_state_add_animation_1Ptr.asFunction<
          spine_track_entry Function(spine_animation_state, int,
              ffi.Pointer<ffi.Char>, bool, double)>();

  spine_track_entry spine_animation_state_add_animation_2(
    spine_animation_state self,
    int trackIndex,
    spine_animation animation,
    bool loop,
    double delay,
  ) {
    return _spine_animation_state_add_animation_2(
      self,
      trackIndex,
      animation,
      loop,
      delay,
    );
  }

  late final _spine_animation_state_add_animation_2Ptr = _lookup<
      ffi.NativeFunction<
          spine_track_entry Function(
              spine_animation_state,
              ffi.Size,
              spine_animation,
              ffi.Bool,
              ffi.Float)>>('spine_animation_state_add_animation_2');
  late final _spine_animation_state_add_animation_2 =
      _spine_animation_state_add_animation_2Ptr.asFunction<
          spine_track_entry Function(
              spine_animation_state, int, spine_animation, bool, double)>();

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

  late final _spine_animation_state_set_empty_animationPtr = _lookup<
      ffi.NativeFunction<
          spine_track_entry Function(spine_animation_state, ffi.Size,
              ffi.Float)>>('spine_animation_state_set_empty_animation');
  late final _spine_animation_state_set_empty_animation =
      _spine_animation_state_set_empty_animationPtr.asFunction<
          spine_track_entry Function(spine_animation_state, int, double)>();

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

  late final _spine_animation_state_add_empty_animationPtr = _lookup<
      ffi.NativeFunction<
          spine_track_entry Function(spine_animation_state, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_animation_state_add_empty_animation');
  late final _spine_animation_state_add_empty_animation =
      _spine_animation_state_add_empty_animationPtr.asFunction<
          spine_track_entry Function(
              spine_animation_state, int, double, double)>();

  void spine_animation_state_set_empty_animations(
    spine_animation_state self,
    double mixDuration,
  ) {
    return _spine_animation_state_set_empty_animations(
      self,
      mixDuration,
    );
  }

  late final _spine_animation_state_set_empty_animationsPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_animation_state, ffi.Float)>>(
      'spine_animation_state_set_empty_animations');
  late final _spine_animation_state_set_empty_animations =
      _spine_animation_state_set_empty_animationsPtr
          .asFunction<void Function(spine_animation_state, double)>();

  spine_track_entry spine_animation_state_get_current(
    spine_animation_state self,
    int trackIndex,
  ) {
    return _spine_animation_state_get_current(
      self,
      trackIndex,
    );
  }

  late final _spine_animation_state_get_currentPtr = _lookup<
      ffi.NativeFunction<
          spine_track_entry Function(spine_animation_state,
              ffi.Size)>>('spine_animation_state_get_current');
  late final _spine_animation_state_get_current =
      _spine_animation_state_get_currentPtr
          .asFunction<spine_track_entry Function(spine_animation_state, int)>();

  spine_animation_state_data spine_animation_state_get_data(
    spine_animation_state self,
  ) {
    return _spine_animation_state_get_data(
      self,
    );
  }

  late final _spine_animation_state_get_dataPtr = _lookup<
      ffi.NativeFunction<
          spine_animation_state_data Function(
              spine_animation_state)>>('spine_animation_state_get_data');
  late final _spine_animation_state_get_data =
      _spine_animation_state_get_dataPtr.asFunction<
          spine_animation_state_data Function(spine_animation_state)>();

  spine_array_track_entry spine_animation_state_get_tracks(
    spine_animation_state self,
  ) {
    return _spine_animation_state_get_tracks(
      self,
    );
  }

  late final _spine_animation_state_get_tracksPtr = _lookup<
      ffi.NativeFunction<
          spine_array_track_entry Function(
              spine_animation_state)>>('spine_animation_state_get_tracks');
  late final _spine_animation_state_get_tracks =
      _spine_animation_state_get_tracksPtr.asFunction<
          spine_array_track_entry Function(spine_animation_state)>();

  double spine_animation_state_get_time_scale(
    spine_animation_state self,
  ) {
    return _spine_animation_state_get_time_scale(
      self,
    );
  }

  late final _spine_animation_state_get_time_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_animation_state)>>(
          'spine_animation_state_get_time_scale');
  late final _spine_animation_state_get_time_scale =
      _spine_animation_state_get_time_scalePtr
          .asFunction<double Function(spine_animation_state)>();

  void spine_animation_state_set_time_scale(
    spine_animation_state self,
    double inValue,
  ) {
    return _spine_animation_state_set_time_scale(
      self,
      inValue,
    );
  }

  late final _spine_animation_state_set_time_scalePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_animation_state, ffi.Float)>>(
      'spine_animation_state_set_time_scale');
  late final _spine_animation_state_set_time_scale =
      _spine_animation_state_set_time_scalePtr
          .asFunction<void Function(spine_animation_state, double)>();

  void spine_animation_state_disable_queue(
    spine_animation_state self,
  ) {
    return _spine_animation_state_disable_queue(
      self,
    );
  }

  late final _spine_animation_state_disable_queuePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state)>>(
          'spine_animation_state_disable_queue');
  late final _spine_animation_state_disable_queue =
      _spine_animation_state_disable_queuePtr
          .asFunction<void Function(spine_animation_state)>();

  void spine_animation_state_enable_queue(
    spine_animation_state self,
  ) {
    return _spine_animation_state_enable_queue(
      self,
    );
  }

  late final _spine_animation_state_enable_queuePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state)>>(
          'spine_animation_state_enable_queue');
  late final _spine_animation_state_enable_queue =
      _spine_animation_state_enable_queuePtr
          .asFunction<void Function(spine_animation_state)>();

  void spine_animation_state_set_manual_track_entry_disposal(
    spine_animation_state self,
    bool inValue,
  ) {
    return _spine_animation_state_set_manual_track_entry_disposal(
      self,
      inValue,
    );
  }

  late final _spine_animation_state_set_manual_track_entry_disposalPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(spine_animation_state, ffi.Bool)>>(
          'spine_animation_state_set_manual_track_entry_disposal');
  late final _spine_animation_state_set_manual_track_entry_disposal =
      _spine_animation_state_set_manual_track_entry_disposalPtr
          .asFunction<void Function(spine_animation_state, bool)>();

  bool spine_animation_state_get_manual_track_entry_disposal(
    spine_animation_state self,
  ) {
    return _spine_animation_state_get_manual_track_entry_disposal(
      self,
    );
  }

  late final _spine_animation_state_get_manual_track_entry_disposalPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_animation_state)>>(
          'spine_animation_state_get_manual_track_entry_disposal');
  late final _spine_animation_state_get_manual_track_entry_disposal =
      _spine_animation_state_get_manual_track_entry_disposalPtr
          .asFunction<bool Function(spine_animation_state)>();

  void spine_animation_state_dispose_track_entry(
    spine_animation_state self,
    spine_track_entry entry,
  ) {
    return _spine_animation_state_dispose_track_entry(
      self,
      entry,
    );
  }

  late final _spine_animation_state_dispose_track_entryPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_animation_state,
              spine_track_entry)>>('spine_animation_state_dispose_track_entry');
  late final _spine_animation_state_dispose_track_entry =
      _spine_animation_state_dispose_track_entryPtr.asFunction<
          void Function(spine_animation_state, spine_track_entry)>();

  ffi.Pointer<ffi.Void> spine_animation_state_get_renderer_object(
    spine_animation_state self,
  ) {
    return _spine_animation_state_get_renderer_object(
      self,
    );
  }

  late final _spine_animation_state_get_renderer_objectPtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Void> Function(spine_animation_state)>>(
      'spine_animation_state_get_renderer_object');
  late final _spine_animation_state_get_renderer_object =
      _spine_animation_state_get_renderer_objectPtr
          .asFunction<ffi.Pointer<ffi.Void> Function(spine_animation_state)>();

  spine_animation_state_data spine_animation_state_data_create(
    spine_skeleton_data skeletonData,
  ) {
    return _spine_animation_state_data_create(
      skeletonData,
    );
  }

  late final _spine_animation_state_data_createPtr = _lookup<
      ffi.NativeFunction<
          spine_animation_state_data Function(
              spine_skeleton_data)>>('spine_animation_state_data_create');
  late final _spine_animation_state_data_create =
      _spine_animation_state_data_createPtr.asFunction<
          spine_animation_state_data Function(spine_skeleton_data)>();

  void spine_animation_state_data_dispose(
    spine_animation_state_data self,
  ) {
    return _spine_animation_state_data_dispose(
      self,
    );
  }

  late final _spine_animation_state_data_disposePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_animation_state_data)>>(
      'spine_animation_state_data_dispose');
  late final _spine_animation_state_data_dispose =
      _spine_animation_state_data_disposePtr
          .asFunction<void Function(spine_animation_state_data)>();

  spine_skeleton_data spine_animation_state_data_get_skeleton_data(
    spine_animation_state_data self,
  ) {
    return _spine_animation_state_data_get_skeleton_data(
      self,
    );
  }

  late final _spine_animation_state_data_get_skeleton_dataPtr = _lookup<
          ffi.NativeFunction<
              spine_skeleton_data Function(spine_animation_state_data)>>(
      'spine_animation_state_data_get_skeleton_data');
  late final _spine_animation_state_data_get_skeleton_data =
      _spine_animation_state_data_get_skeleton_dataPtr.asFunction<
          spine_skeleton_data Function(spine_animation_state_data)>();

  double spine_animation_state_data_get_default_mix(
    spine_animation_state_data self,
  ) {
    return _spine_animation_state_data_get_default_mix(
      self,
    );
  }

  late final _spine_animation_state_data_get_default_mixPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_animation_state_data)>>(
      'spine_animation_state_data_get_default_mix');
  late final _spine_animation_state_data_get_default_mix =
      _spine_animation_state_data_get_default_mixPtr
          .asFunction<double Function(spine_animation_state_data)>();

  void spine_animation_state_data_set_default_mix(
    spine_animation_state_data self,
    double inValue,
  ) {
    return _spine_animation_state_data_set_default_mix(
      self,
      inValue,
    );
  }

  late final _spine_animation_state_data_set_default_mixPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_animation_state_data,
              ffi.Float)>>('spine_animation_state_data_set_default_mix');
  late final _spine_animation_state_data_set_default_mix =
      _spine_animation_state_data_set_default_mixPtr
          .asFunction<void Function(spine_animation_state_data, double)>();

  void spine_animation_state_data_set_mix_1(
    spine_animation_state_data self,
    ffi.Pointer<ffi.Char> fromName,
    ffi.Pointer<ffi.Char> toName,
    double duration,
  ) {
    return _spine_animation_state_data_set_mix_1(
      self,
      fromName,
      toName,
      duration,
    );
  }

  late final _spine_animation_state_data_set_mix_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_animation_state_data,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              ffi.Float)>>('spine_animation_state_data_set_mix_1');
  late final _spine_animation_state_data_set_mix_1 =
      _spine_animation_state_data_set_mix_1Ptr.asFunction<
          void Function(spine_animation_state_data, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>, double)>();

  void spine_animation_state_data_set_mix_2(
    spine_animation_state_data self,
    spine_animation from,
    spine_animation to,
    double duration,
  ) {
    return _spine_animation_state_data_set_mix_2(
      self,
      from,
      to,
      duration,
    );
  }

  late final _spine_animation_state_data_set_mix_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_animation_state_data,
              spine_animation,
              spine_animation,
              ffi.Float)>>('spine_animation_state_data_set_mix_2');
  late final _spine_animation_state_data_set_mix_2 =
      _spine_animation_state_data_set_mix_2Ptr.asFunction<
          void Function(spine_animation_state_data, spine_animation,
              spine_animation, double)>();

  double spine_animation_state_data_get_mix(
    spine_animation_state_data self,
    spine_animation from,
    spine_animation to,
  ) {
    return _spine_animation_state_data_get_mix(
      self,
      from,
      to,
    );
  }

  late final _spine_animation_state_data_get_mixPtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_animation_state_data, spine_animation,
              spine_animation)>>('spine_animation_state_data_get_mix');
  late final _spine_animation_state_data_get_mix =
      _spine_animation_state_data_get_mixPtr.asFunction<
          double Function(
              spine_animation_state_data, spine_animation, spine_animation)>();

  void spine_animation_state_data_clear(
    spine_animation_state_data self,
  ) {
    return _spine_animation_state_data_clear(
      self,
    );
  }

  late final _spine_animation_state_data_clearPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_animation_state_data)>>(
      'spine_animation_state_data_clear');
  late final _spine_animation_state_data_clear =
      _spine_animation_state_data_clearPtr
          .asFunction<void Function(spine_animation_state_data)>();

  void spine_atlas_flip_v(
    spine_atlas self,
  ) {
    return _spine_atlas_flip_v(
      self,
    );
  }

  late final _spine_atlas_flip_vPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas)>>(
          'spine_atlas_flip_v');
  late final _spine_atlas_flip_v =
      _spine_atlas_flip_vPtr.asFunction<void Function(spine_atlas)>();

  spine_atlas_region spine_atlas_find_region(
    spine_atlas self,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_atlas_find_region(
      self,
      name,
    );
  }

  late final _spine_atlas_find_regionPtr = _lookup<
      ffi.NativeFunction<
          spine_atlas_region Function(
              spine_atlas, ffi.Pointer<ffi.Char>)>>('spine_atlas_find_region');
  late final _spine_atlas_find_region = _spine_atlas_find_regionPtr.asFunction<
      spine_atlas_region Function(spine_atlas, ffi.Pointer<ffi.Char>)>();

  spine_array_atlas_page spine_atlas_get_pages(
    spine_atlas self,
  ) {
    return _spine_atlas_get_pages(
      self,
    );
  }

  late final _spine_atlas_get_pagesPtr =
      _lookup<ffi.NativeFunction<spine_array_atlas_page Function(spine_atlas)>>(
          'spine_atlas_get_pages');
  late final _spine_atlas_get_pages = _spine_atlas_get_pagesPtr
      .asFunction<spine_array_atlas_page Function(spine_atlas)>();

  spine_array_atlas_region spine_atlas_get_regions(
    spine_atlas self,
  ) {
    return _spine_atlas_get_regions(
      self,
    );
  }

  late final _spine_atlas_get_regionsPtr = _lookup<
          ffi.NativeFunction<spine_array_atlas_region Function(spine_atlas)>>(
      'spine_atlas_get_regions');
  late final _spine_atlas_get_regions = _spine_atlas_get_regionsPtr
      .asFunction<spine_array_atlas_region Function(spine_atlas)>();

  spine_atlas_attachment_loader spine_atlas_attachment_loader_create(
    spine_atlas atlas,
  ) {
    return _spine_atlas_attachment_loader_create(
      atlas,
    );
  }

  late final _spine_atlas_attachment_loader_createPtr = _lookup<
          ffi
          .NativeFunction<spine_atlas_attachment_loader Function(spine_atlas)>>(
      'spine_atlas_attachment_loader_create');
  late final _spine_atlas_attachment_loader_create =
      _spine_atlas_attachment_loader_createPtr
          .asFunction<spine_atlas_attachment_loader Function(spine_atlas)>();

  void spine_atlas_attachment_loader_dispose(
    spine_atlas_attachment_loader self,
  ) {
    return _spine_atlas_attachment_loader_dispose(
      self,
    );
  }

  late final _spine_atlas_attachment_loader_disposePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_attachment_loader)>>(
      'spine_atlas_attachment_loader_dispose');
  late final _spine_atlas_attachment_loader_dispose =
      _spine_atlas_attachment_loader_disposePtr
          .asFunction<void Function(spine_atlas_attachment_loader)>();

  spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(
    spine_atlas_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
    ffi.Pointer<ffi.Char> path,
    spine_sequence sequence,
  ) {
    return _spine_atlas_attachment_loader_new_region_attachment(
      self,
      skin,
      name,
      path,
      sequence,
    );
  }

  late final _spine_atlas_attachment_loader_new_region_attachmentPtr = _lookup<
          ffi.NativeFunction<
              spine_region_attachment Function(
                  spine_atlas_attachment_loader,
                  spine_skin,
                  ffi.Pointer<ffi.Char>,
                  ffi.Pointer<ffi.Char>,
                  spine_sequence)>>(
      'spine_atlas_attachment_loader_new_region_attachment');
  late final _spine_atlas_attachment_loader_new_region_attachment =
      _spine_atlas_attachment_loader_new_region_attachmentPtr.asFunction<
          spine_region_attachment Function(
              spine_atlas_attachment_loader,
              spine_skin,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              spine_sequence)>();

  spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(
    spine_atlas_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
    ffi.Pointer<ffi.Char> path,
    spine_sequence sequence,
  ) {
    return _spine_atlas_attachment_loader_new_mesh_attachment(
      self,
      skin,
      name,
      path,
      sequence,
    );
  }

  late final _spine_atlas_attachment_loader_new_mesh_attachmentPtr = _lookup<
          ffi.NativeFunction<
              spine_mesh_attachment Function(
                  spine_atlas_attachment_loader,
                  spine_skin,
                  ffi.Pointer<ffi.Char>,
                  ffi.Pointer<ffi.Char>,
                  spine_sequence)>>(
      'spine_atlas_attachment_loader_new_mesh_attachment');
  late final _spine_atlas_attachment_loader_new_mesh_attachment =
      _spine_atlas_attachment_loader_new_mesh_attachmentPtr.asFunction<
          spine_mesh_attachment Function(
              spine_atlas_attachment_loader,
              spine_skin,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              spine_sequence)>();

  spine_bounding_box_attachment
      spine_atlas_attachment_loader_new_bounding_box_attachment(
    spine_atlas_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_atlas_attachment_loader_new_bounding_box_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_atlas_attachment_loader_new_bounding_box_attachmentPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_bounding_box_attachment Function(
                      spine_atlas_attachment_loader,
                      spine_skin,
                      ffi.Pointer<ffi.Char>)>>(
          'spine_atlas_attachment_loader_new_bounding_box_attachment');
  late final _spine_atlas_attachment_loader_new_bounding_box_attachment =
      _spine_atlas_attachment_loader_new_bounding_box_attachmentPtr.asFunction<
          spine_bounding_box_attachment Function(spine_atlas_attachment_loader,
              spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(
    spine_atlas_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_atlas_attachment_loader_new_path_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_atlas_attachment_loader_new_path_attachmentPtr = _lookup<
          ffi.NativeFunction<
              spine_path_attachment Function(spine_atlas_attachment_loader,
                  spine_skin, ffi.Pointer<ffi.Char>)>>(
      'spine_atlas_attachment_loader_new_path_attachment');
  late final _spine_atlas_attachment_loader_new_path_attachment =
      _spine_atlas_attachment_loader_new_path_attachmentPtr.asFunction<
          spine_path_attachment Function(spine_atlas_attachment_loader,
              spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(
    spine_atlas_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_atlas_attachment_loader_new_point_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_atlas_attachment_loader_new_point_attachmentPtr = _lookup<
          ffi.NativeFunction<
              spine_point_attachment Function(spine_atlas_attachment_loader,
                  spine_skin, ffi.Pointer<ffi.Char>)>>(
      'spine_atlas_attachment_loader_new_point_attachment');
  late final _spine_atlas_attachment_loader_new_point_attachment =
      _spine_atlas_attachment_loader_new_point_attachmentPtr.asFunction<
          spine_point_attachment Function(spine_atlas_attachment_loader,
              spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_clipping_attachment
      spine_atlas_attachment_loader_new_clipping_attachment(
    spine_atlas_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_atlas_attachment_loader_new_clipping_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_atlas_attachment_loader_new_clipping_attachmentPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_clipping_attachment Function(
                      spine_atlas_attachment_loader,
                      spine_skin,
                      ffi.Pointer<ffi.Char>)>>(
          'spine_atlas_attachment_loader_new_clipping_attachment');
  late final _spine_atlas_attachment_loader_new_clipping_attachment =
      _spine_atlas_attachment_loader_new_clipping_attachmentPtr.asFunction<
          spine_clipping_attachment Function(spine_atlas_attachment_loader,
              spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_atlas_region spine_atlas_attachment_loader_find_region(
    spine_atlas_attachment_loader self,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_atlas_attachment_loader_find_region(
      self,
      name,
    );
  }

  late final _spine_atlas_attachment_loader_find_regionPtr = _lookup<
          ffi.NativeFunction<
              spine_atlas_region Function(
                  spine_atlas_attachment_loader, ffi.Pointer<ffi.Char>)>>(
      'spine_atlas_attachment_loader_find_region');
  late final _spine_atlas_attachment_loader_find_region =
      _spine_atlas_attachment_loader_find_regionPtr.asFunction<
          spine_atlas_region Function(
              spine_atlas_attachment_loader, ffi.Pointer<ffi.Char>)>();

  spine_atlas_page spine_atlas_page_create(
    ffi.Pointer<ffi.Char> inName,
  ) {
    return _spine_atlas_page_create(
      inName,
    );
  }

  late final _spine_atlas_page_createPtr = _lookup<
          ffi.NativeFunction<spine_atlas_page Function(ffi.Pointer<ffi.Char>)>>(
      'spine_atlas_page_create');
  late final _spine_atlas_page_create = _spine_atlas_page_createPtr
      .asFunction<spine_atlas_page Function(ffi.Pointer<ffi.Char>)>();

  void spine_atlas_page_dispose(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_dispose(
      self,
    );
  }

  late final _spine_atlas_page_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page)>>(
          'spine_atlas_page_dispose');
  late final _spine_atlas_page_dispose = _spine_atlas_page_disposePtr
      .asFunction<void Function(spine_atlas_page)>();

  ffi.Pointer<ffi.Char> spine_atlas_page_get_name(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_name(
      self,
    );
  }

  late final _spine_atlas_page_get_namePtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_atlas_page)>>(
      'spine_atlas_page_get_name');
  late final _spine_atlas_page_get_name = _spine_atlas_page_get_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_atlas_page)>();

  void spine_atlas_page_set_name(
    spine_atlas_page self,
    ffi.Pointer<ffi.Char> value,
  ) {
    return _spine_atlas_page_set_name(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_atlas_page,
              ffi.Pointer<ffi.Char>)>>('spine_atlas_page_set_name');
  late final _spine_atlas_page_set_name = _spine_atlas_page_set_namePtr
      .asFunction<void Function(spine_atlas_page, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> spine_atlas_page_get_texture_path(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_texture_path(
      self,
    );
  }

  late final _spine_atlas_page_get_texture_pathPtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_atlas_page)>>(
      'spine_atlas_page_get_texture_path');
  late final _spine_atlas_page_get_texture_path =
      _spine_atlas_page_get_texture_pathPtr
          .asFunction<ffi.Pointer<ffi.Char> Function(spine_atlas_page)>();

  void spine_atlas_page_set_texture_path(
    spine_atlas_page self,
    ffi.Pointer<ffi.Char> value,
  ) {
    return _spine_atlas_page_set_texture_path(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_texture_pathPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_atlas_page,
              ffi.Pointer<ffi.Char>)>>('spine_atlas_page_set_texture_path');
  late final _spine_atlas_page_set_texture_path =
      _spine_atlas_page_set_texture_pathPtr
          .asFunction<void Function(spine_atlas_page, ffi.Pointer<ffi.Char>)>();

  int spine_atlas_page_get_format(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_format(
      self,
    );
  }

  late final _spine_atlas_page_get_formatPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_atlas_page)>>(
          'spine_atlas_page_get_format');
  late final _spine_atlas_page_get_format = _spine_atlas_page_get_formatPtr
      .asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_format(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_format(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_formatPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int32)>>(
      'spine_atlas_page_set_format');
  late final _spine_atlas_page_set_format = _spine_atlas_page_set_formatPtr
      .asFunction<void Function(spine_atlas_page, int)>();

  int spine_atlas_page_get_min_filter(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_min_filter(
      self,
    );
  }

  late final _spine_atlas_page_get_min_filterPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_atlas_page)>>(
          'spine_atlas_page_get_min_filter');
  late final _spine_atlas_page_get_min_filter =
      _spine_atlas_page_get_min_filterPtr
          .asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_min_filter(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_min_filter(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_min_filterPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int32)>>(
      'spine_atlas_page_set_min_filter');
  late final _spine_atlas_page_set_min_filter =
      _spine_atlas_page_set_min_filterPtr
          .asFunction<void Function(spine_atlas_page, int)>();

  int spine_atlas_page_get_mag_filter(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_mag_filter(
      self,
    );
  }

  late final _spine_atlas_page_get_mag_filterPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_atlas_page)>>(
          'spine_atlas_page_get_mag_filter');
  late final _spine_atlas_page_get_mag_filter =
      _spine_atlas_page_get_mag_filterPtr
          .asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_mag_filter(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_mag_filter(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_mag_filterPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int32)>>(
      'spine_atlas_page_set_mag_filter');
  late final _spine_atlas_page_set_mag_filter =
      _spine_atlas_page_set_mag_filterPtr
          .asFunction<void Function(spine_atlas_page, int)>();

  int spine_atlas_page_get_u_wrap(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_u_wrap(
      self,
    );
  }

  late final _spine_atlas_page_get_u_wrapPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_atlas_page)>>(
          'spine_atlas_page_get_u_wrap');
  late final _spine_atlas_page_get_u_wrap = _spine_atlas_page_get_u_wrapPtr
      .asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_u_wrap(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_u_wrap(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_u_wrapPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int32)>>(
      'spine_atlas_page_set_u_wrap');
  late final _spine_atlas_page_set_u_wrap = _spine_atlas_page_set_u_wrapPtr
      .asFunction<void Function(spine_atlas_page, int)>();

  int spine_atlas_page_get_v_wrap(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_v_wrap(
      self,
    );
  }

  late final _spine_atlas_page_get_v_wrapPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_atlas_page)>>(
          'spine_atlas_page_get_v_wrap');
  late final _spine_atlas_page_get_v_wrap = _spine_atlas_page_get_v_wrapPtr
      .asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_v_wrap(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_v_wrap(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_v_wrapPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int32)>>(
      'spine_atlas_page_set_v_wrap');
  late final _spine_atlas_page_set_v_wrap = _spine_atlas_page_set_v_wrapPtr
      .asFunction<void Function(spine_atlas_page, int)>();

  int spine_atlas_page_get_width(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_width(
      self,
    );
  }

  late final _spine_atlas_page_get_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_page)>>(
          'spine_atlas_page_get_width');
  late final _spine_atlas_page_get_width = _spine_atlas_page_get_widthPtr
      .asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_width(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_width(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int)>>(
          'spine_atlas_page_set_width');
  late final _spine_atlas_page_set_width = _spine_atlas_page_set_widthPtr
      .asFunction<void Function(spine_atlas_page, int)>();

  int spine_atlas_page_get_height(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_height(
      self,
    );
  }

  late final _spine_atlas_page_get_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_page)>>(
          'spine_atlas_page_get_height');
  late final _spine_atlas_page_get_height = _spine_atlas_page_get_heightPtr
      .asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_height(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_height(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int)>>(
          'spine_atlas_page_set_height');
  late final _spine_atlas_page_set_height = _spine_atlas_page_set_heightPtr
      .asFunction<void Function(spine_atlas_page, int)>();

  bool spine_atlas_page_get_pma(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_pma(
      self,
    );
  }

  late final _spine_atlas_page_get_pmaPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_atlas_page)>>(
          'spine_atlas_page_get_pma');
  late final _spine_atlas_page_get_pma = _spine_atlas_page_get_pmaPtr
      .asFunction<bool Function(spine_atlas_page)>();

  void spine_atlas_page_set_pma(
    spine_atlas_page self,
    bool value,
  ) {
    return _spine_atlas_page_set_pma(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_pmaPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Bool)>>(
      'spine_atlas_page_set_pma');
  late final _spine_atlas_page_set_pma = _spine_atlas_page_set_pmaPtr
      .asFunction<void Function(spine_atlas_page, bool)>();

  int spine_atlas_page_get_index(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_index(
      self,
    );
  }

  late final _spine_atlas_page_get_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_page)>>(
          'spine_atlas_page_get_index');
  late final _spine_atlas_page_get_index = _spine_atlas_page_get_indexPtr
      .asFunction<int Function(spine_atlas_page)>();

  void spine_atlas_page_set_index(
    spine_atlas_page self,
    int value,
  ) {
    return _spine_atlas_page_set_index(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_page, ffi.Int)>>(
          'spine_atlas_page_set_index');
  late final _spine_atlas_page_set_index = _spine_atlas_page_set_indexPtr
      .asFunction<void Function(spine_atlas_page, int)>();

  ffi.Pointer<ffi.Void> spine_atlas_page_get_texture(
    spine_atlas_page self,
  ) {
    return _spine_atlas_page_get_texture(
      self,
    );
  }

  late final _spine_atlas_page_get_texturePtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(spine_atlas_page)>>(
      'spine_atlas_page_get_texture');
  late final _spine_atlas_page_get_texture = _spine_atlas_page_get_texturePtr
      .asFunction<ffi.Pointer<ffi.Void> Function(spine_atlas_page)>();

  void spine_atlas_page_set_texture(
    spine_atlas_page self,
    ffi.Pointer<ffi.Void> value,
  ) {
    return _spine_atlas_page_set_texture(
      self,
      value,
    );
  }

  late final _spine_atlas_page_set_texturePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_atlas_page,
              ffi.Pointer<ffi.Void>)>>('spine_atlas_page_set_texture');
  late final _spine_atlas_page_set_texture = _spine_atlas_page_set_texturePtr
      .asFunction<void Function(spine_atlas_page, ffi.Pointer<ffi.Void>)>();

  spine_atlas_region spine_atlas_region_create() {
    return _spine_atlas_region_create();
  }

  late final _spine_atlas_region_createPtr =
      _lookup<ffi.NativeFunction<spine_atlas_region Function()>>(
          'spine_atlas_region_create');
  late final _spine_atlas_region_create =
      _spine_atlas_region_createPtr.asFunction<spine_atlas_region Function()>();

  void spine_atlas_region_dispose(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_dispose(
      self,
    );
  }

  late final _spine_atlas_region_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas_region)>>(
          'spine_atlas_region_dispose');
  late final _spine_atlas_region_dispose = _spine_atlas_region_disposePtr
      .asFunction<void Function(spine_atlas_region)>();

  spine_rtti spine_atlas_region_get_rtti(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_rtti(
      self,
    );
  }

  late final _spine_atlas_region_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_atlas_region)>>(
          'spine_atlas_region_get_rtti');
  late final _spine_atlas_region_get_rtti = _spine_atlas_region_get_rttiPtr
      .asFunction<spine_rtti Function(spine_atlas_region)>();

  spine_atlas_page spine_atlas_region_get_page(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_page(
      self,
    );
  }

  late final _spine_atlas_region_get_pagePtr = _lookup<
          ffi.NativeFunction<spine_atlas_page Function(spine_atlas_region)>>(
      'spine_atlas_region_get_page');
  late final _spine_atlas_region_get_page = _spine_atlas_region_get_pagePtr
      .asFunction<spine_atlas_page Function(spine_atlas_region)>();

  int spine_atlas_region_get_index(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_index(
      self,
    );
  }

  late final _spine_atlas_region_get_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>(
          'spine_atlas_region_get_index');
  late final _spine_atlas_region_get_index = _spine_atlas_region_get_indexPtr
      .asFunction<int Function(spine_atlas_region)>();

  int spine_atlas_region_get_x(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_x(
      self,
    );
  }

  late final _spine_atlas_region_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>(
          'spine_atlas_region_get_x');
  late final _spine_atlas_region_get_x = _spine_atlas_region_get_xPtr
      .asFunction<int Function(spine_atlas_region)>();

  int spine_atlas_region_get_y(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_y(
      self,
    );
  }

  late final _spine_atlas_region_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>(
          'spine_atlas_region_get_y');
  late final _spine_atlas_region_get_y = _spine_atlas_region_get_yPtr
      .asFunction<int Function(spine_atlas_region)>();

  double spine_atlas_region_get_offset_x(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_offset_x(
      self,
    );
  }

  late final _spine_atlas_region_get_offset_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_atlas_region)>>(
          'spine_atlas_region_get_offset_x');
  late final _spine_atlas_region_get_offset_x =
      _spine_atlas_region_get_offset_xPtr
          .asFunction<double Function(spine_atlas_region)>();

  double spine_atlas_region_get_offset_y(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_offset_y(
      self,
    );
  }

  late final _spine_atlas_region_get_offset_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_atlas_region)>>(
          'spine_atlas_region_get_offset_y');
  late final _spine_atlas_region_get_offset_y =
      _spine_atlas_region_get_offset_yPtr
          .asFunction<double Function(spine_atlas_region)>();

  int spine_atlas_region_get_packed_width(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_packed_width(
      self,
    );
  }

  late final _spine_atlas_region_get_packed_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>(
          'spine_atlas_region_get_packed_width');
  late final _spine_atlas_region_get_packed_width =
      _spine_atlas_region_get_packed_widthPtr
          .asFunction<int Function(spine_atlas_region)>();

  int spine_atlas_region_get_packed_height(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_packed_height(
      self,
    );
  }

  late final _spine_atlas_region_get_packed_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>(
          'spine_atlas_region_get_packed_height');
  late final _spine_atlas_region_get_packed_height =
      _spine_atlas_region_get_packed_heightPtr
          .asFunction<int Function(spine_atlas_region)>();

  int spine_atlas_region_get_original_width(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_original_width(
      self,
    );
  }

  late final _spine_atlas_region_get_original_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>(
          'spine_atlas_region_get_original_width');
  late final _spine_atlas_region_get_original_width =
      _spine_atlas_region_get_original_widthPtr
          .asFunction<int Function(spine_atlas_region)>();

  int spine_atlas_region_get_original_height(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_original_height(
      self,
    );
  }

  late final _spine_atlas_region_get_original_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>(
          'spine_atlas_region_get_original_height');
  late final _spine_atlas_region_get_original_height =
      _spine_atlas_region_get_original_heightPtr
          .asFunction<int Function(spine_atlas_region)>();

  bool spine_atlas_region_get_rotate(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_rotate(
      self,
    );
  }

  late final _spine_atlas_region_get_rotatePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_atlas_region)>>(
          'spine_atlas_region_get_rotate');
  late final _spine_atlas_region_get_rotate = _spine_atlas_region_get_rotatePtr
      .asFunction<bool Function(spine_atlas_region)>();

  int spine_atlas_region_get_degrees(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_degrees(
      self,
    );
  }

  late final _spine_atlas_region_get_degreesPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>(
          'spine_atlas_region_get_degrees');
  late final _spine_atlas_region_get_degrees =
      _spine_atlas_region_get_degreesPtr
          .asFunction<int Function(spine_atlas_region)>();

  spine_array_int spine_atlas_region_get_splits(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_splits(
      self,
    );
  }

  late final _spine_atlas_region_get_splitsPtr =
      _lookup<ffi.NativeFunction<spine_array_int Function(spine_atlas_region)>>(
          'spine_atlas_region_get_splits');
  late final _spine_atlas_region_get_splits = _spine_atlas_region_get_splitsPtr
      .asFunction<spine_array_int Function(spine_atlas_region)>();

  spine_array_int spine_atlas_region_get_pads(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_pads(
      self,
    );
  }

  late final _spine_atlas_region_get_padsPtr =
      _lookup<ffi.NativeFunction<spine_array_int Function(spine_atlas_region)>>(
          'spine_atlas_region_get_pads');
  late final _spine_atlas_region_get_pads = _spine_atlas_region_get_padsPtr
      .asFunction<spine_array_int Function(spine_atlas_region)>();

  spine_array_float spine_atlas_region_get_values(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_values(
      self,
    );
  }

  late final _spine_atlas_region_get_valuesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_atlas_region)>>(
      'spine_atlas_region_get_values');
  late final _spine_atlas_region_get_values = _spine_atlas_region_get_valuesPtr
      .asFunction<spine_array_float Function(spine_atlas_region)>();

  void spine_atlas_region_set_page(
    spine_atlas_region self,
    spine_atlas_page value,
  ) {
    return _spine_atlas_region_set_page(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_pagePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_atlas_region,
              spine_atlas_page)>>('spine_atlas_region_set_page');
  late final _spine_atlas_region_set_page = _spine_atlas_region_set_pagePtr
      .asFunction<void Function(spine_atlas_region, spine_atlas_page)>();

  void spine_atlas_region_set_name(
    spine_atlas_region self,
    ffi.Pointer<ffi.Char> value,
  ) {
    return _spine_atlas_region_set_name(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_atlas_region,
              ffi.Pointer<ffi.Char>)>>('spine_atlas_region_set_name');
  late final _spine_atlas_region_set_name = _spine_atlas_region_set_namePtr
      .asFunction<void Function(spine_atlas_region, ffi.Pointer<ffi.Char>)>();

  void spine_atlas_region_set_index(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_index(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_indexPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
      'spine_atlas_region_set_index');
  late final _spine_atlas_region_set_index = _spine_atlas_region_set_indexPtr
      .asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_x(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_x(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_xPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
      'spine_atlas_region_set_x');
  late final _spine_atlas_region_set_x = _spine_atlas_region_set_xPtr
      .asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_y(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_y(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_yPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
      'spine_atlas_region_set_y');
  late final _spine_atlas_region_set_y = _spine_atlas_region_set_yPtr
      .asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_offset_x(
    spine_atlas_region self,
    double value,
  ) {
    return _spine_atlas_region_set_offset_x(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_offset_xPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Float)>>(
      'spine_atlas_region_set_offset_x');
  late final _spine_atlas_region_set_offset_x =
      _spine_atlas_region_set_offset_xPtr
          .asFunction<void Function(spine_atlas_region, double)>();

  void spine_atlas_region_set_offset_y(
    spine_atlas_region self,
    double value,
  ) {
    return _spine_atlas_region_set_offset_y(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_offset_yPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Float)>>(
      'spine_atlas_region_set_offset_y');
  late final _spine_atlas_region_set_offset_y =
      _spine_atlas_region_set_offset_yPtr
          .asFunction<void Function(spine_atlas_region, double)>();

  void spine_atlas_region_set_packed_width(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_packed_width(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_packed_widthPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
      'spine_atlas_region_set_packed_width');
  late final _spine_atlas_region_set_packed_width =
      _spine_atlas_region_set_packed_widthPtr
          .asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_packed_height(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_packed_height(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_packed_heightPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
      'spine_atlas_region_set_packed_height');
  late final _spine_atlas_region_set_packed_height =
      _spine_atlas_region_set_packed_heightPtr
          .asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_original_width(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_original_width(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_original_widthPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
      'spine_atlas_region_set_original_width');
  late final _spine_atlas_region_set_original_width =
      _spine_atlas_region_set_original_widthPtr
          .asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_original_height(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_original_height(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_original_heightPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
      'spine_atlas_region_set_original_height');
  late final _spine_atlas_region_set_original_height =
      _spine_atlas_region_set_original_heightPtr
          .asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_rotate(
    spine_atlas_region self,
    bool value,
  ) {
    return _spine_atlas_region_set_rotate(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_rotatePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Bool)>>(
      'spine_atlas_region_set_rotate');
  late final _spine_atlas_region_set_rotate = _spine_atlas_region_set_rotatePtr
      .asFunction<void Function(spine_atlas_region, bool)>();

  void spine_atlas_region_set_degrees(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_degrees(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_degreesPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
      'spine_atlas_region_set_degrees');
  late final _spine_atlas_region_set_degrees =
      _spine_atlas_region_set_degreesPtr
          .asFunction<void Function(spine_atlas_region, int)>();

  void spine_atlas_region_set_splits(
    spine_atlas_region self,
    spine_array_int value,
  ) {
    return _spine_atlas_region_set_splits(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_splitsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_atlas_region,
              spine_array_int)>>('spine_atlas_region_set_splits');
  late final _spine_atlas_region_set_splits = _spine_atlas_region_set_splitsPtr
      .asFunction<void Function(spine_atlas_region, spine_array_int)>();

  void spine_atlas_region_set_pads(
    spine_atlas_region self,
    spine_array_int value,
  ) {
    return _spine_atlas_region_set_pads(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_padsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_atlas_region,
              spine_array_int)>>('spine_atlas_region_set_pads');
  late final _spine_atlas_region_set_pads = _spine_atlas_region_set_padsPtr
      .asFunction<void Function(spine_atlas_region, spine_array_int)>();

  void spine_atlas_region_set_values(
    spine_atlas_region self,
    spine_array_float value,
  ) {
    return _spine_atlas_region_set_values(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_valuesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_atlas_region,
              spine_array_float)>>('spine_atlas_region_set_values');
  late final _spine_atlas_region_set_values = _spine_atlas_region_set_valuesPtr
      .asFunction<void Function(spine_atlas_region, spine_array_float)>();

  double spine_atlas_region_get_u(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_u(
      self,
    );
  }

  late final _spine_atlas_region_get_uPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_atlas_region)>>(
          'spine_atlas_region_get_u');
  late final _spine_atlas_region_get_u = _spine_atlas_region_get_uPtr
      .asFunction<double Function(spine_atlas_region)>();

  void spine_atlas_region_set_u(
    spine_atlas_region self,
    double value,
  ) {
    return _spine_atlas_region_set_u(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_uPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Float)>>(
      'spine_atlas_region_set_u');
  late final _spine_atlas_region_set_u = _spine_atlas_region_set_uPtr
      .asFunction<void Function(spine_atlas_region, double)>();

  double spine_atlas_region_get_v(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_v(
      self,
    );
  }

  late final _spine_atlas_region_get_vPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_atlas_region)>>(
          'spine_atlas_region_get_v');
  late final _spine_atlas_region_get_v = _spine_atlas_region_get_vPtr
      .asFunction<double Function(spine_atlas_region)>();

  void spine_atlas_region_set_v(
    spine_atlas_region self,
    double value,
  ) {
    return _spine_atlas_region_set_v(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_vPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Float)>>(
      'spine_atlas_region_set_v');
  late final _spine_atlas_region_set_v = _spine_atlas_region_set_vPtr
      .asFunction<void Function(spine_atlas_region, double)>();

  double spine_atlas_region_get_u2(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_u2(
      self,
    );
  }

  late final _spine_atlas_region_get_u2Ptr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_atlas_region)>>(
          'spine_atlas_region_get_u2');
  late final _spine_atlas_region_get_u2 = _spine_atlas_region_get_u2Ptr
      .asFunction<double Function(spine_atlas_region)>();

  void spine_atlas_region_set_u2(
    spine_atlas_region self,
    double value,
  ) {
    return _spine_atlas_region_set_u2(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_u2Ptr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Float)>>(
      'spine_atlas_region_set_u2');
  late final _spine_atlas_region_set_u2 = _spine_atlas_region_set_u2Ptr
      .asFunction<void Function(spine_atlas_region, double)>();

  double spine_atlas_region_get_v2(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_v2(
      self,
    );
  }

  late final _spine_atlas_region_get_v2Ptr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_atlas_region)>>(
          'spine_atlas_region_get_v2');
  late final _spine_atlas_region_get_v2 = _spine_atlas_region_get_v2Ptr
      .asFunction<double Function(spine_atlas_region)>();

  void spine_atlas_region_set_v2(
    spine_atlas_region self,
    double value,
  ) {
    return _spine_atlas_region_set_v2(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_v2Ptr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Float)>>(
      'spine_atlas_region_set_v2');
  late final _spine_atlas_region_set_v2 = _spine_atlas_region_set_v2Ptr
      .asFunction<void Function(spine_atlas_region, double)>();

  int spine_atlas_region_get_region_width(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_region_width(
      self,
    );
  }

  late final _spine_atlas_region_get_region_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>(
          'spine_atlas_region_get_region_width');
  late final _spine_atlas_region_get_region_width =
      _spine_atlas_region_get_region_widthPtr
          .asFunction<int Function(spine_atlas_region)>();

  void spine_atlas_region_set_region_width(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_region_width(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_region_widthPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
      'spine_atlas_region_set_region_width');
  late final _spine_atlas_region_set_region_width =
      _spine_atlas_region_set_region_widthPtr
          .asFunction<void Function(spine_atlas_region, int)>();

  int spine_atlas_region_get_region_height(
    spine_atlas_region self,
  ) {
    return _spine_atlas_region_get_region_height(
      self,
    );
  }

  late final _spine_atlas_region_get_region_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_atlas_region)>>(
          'spine_atlas_region_get_region_height');
  late final _spine_atlas_region_get_region_height =
      _spine_atlas_region_get_region_heightPtr
          .asFunction<int Function(spine_atlas_region)>();

  void spine_atlas_region_set_region_height(
    spine_atlas_region self,
    int value,
  ) {
    return _spine_atlas_region_set_region_height(
      self,
      value,
    );
  }

  late final _spine_atlas_region_set_region_heightPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_atlas_region, ffi.Int)>>(
      'spine_atlas_region_set_region_height');
  late final _spine_atlas_region_set_region_height =
      _spine_atlas_region_set_region_heightPtr
          .asFunction<void Function(spine_atlas_region, int)>();

  spine_rtti spine_atlas_region_rtti() {
    return _spine_atlas_region_rtti();
  }

  late final _spine_atlas_region_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_atlas_region_rtti');
  late final _spine_atlas_region_rtti =
      _spine_atlas_region_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_attachment_dispose(
    spine_attachment self,
  ) {
    return _spine_attachment_dispose(
      self,
    );
  }

  late final _spine_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_attachment)>>(
          'spine_attachment_dispose');
  late final _spine_attachment_dispose = _spine_attachment_disposePtr
      .asFunction<void Function(spine_attachment)>();

  spine_rtti spine_attachment_get_rtti(
    spine_attachment self,
  ) {
    return _spine_attachment_get_rtti(
      self,
    );
  }

  late final _spine_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_attachment)>>(
          'spine_attachment_get_rtti');
  late final _spine_attachment_get_rtti = _spine_attachment_get_rttiPtr
      .asFunction<spine_rtti Function(spine_attachment)>();

  ffi.Pointer<ffi.Char> spine_attachment_get_name(
    spine_attachment self,
  ) {
    return _spine_attachment_get_name(
      self,
    );
  }

  late final _spine_attachment_get_namePtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_attachment)>>(
      'spine_attachment_get_name');
  late final _spine_attachment_get_name = _spine_attachment_get_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_attachment)>();

  spine_attachment spine_attachment_copy(
    spine_attachment self,
  ) {
    return _spine_attachment_copy(
      self,
    );
  }

  late final _spine_attachment_copyPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_attachment)>>(
          'spine_attachment_copy');
  late final _spine_attachment_copy = _spine_attachment_copyPtr
      .asFunction<spine_attachment Function(spine_attachment)>();

  int spine_attachment_get_ref_count(
    spine_attachment self,
  ) {
    return _spine_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_attachment)>>(
          'spine_attachment_get_ref_count');
  late final _spine_attachment_get_ref_count =
      _spine_attachment_get_ref_countPtr
          .asFunction<int Function(spine_attachment)>();

  void spine_attachment_reference(
    spine_attachment self,
  ) {
    return _spine_attachment_reference(
      self,
    );
  }

  late final _spine_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_attachment)>>(
          'spine_attachment_reference');
  late final _spine_attachment_reference = _spine_attachment_referencePtr
      .asFunction<void Function(spine_attachment)>();

  void spine_attachment_dereference(
    spine_attachment self,
  ) {
    return _spine_attachment_dereference(
      self,
    );
  }

  late final _spine_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_attachment)>>(
          'spine_attachment_dereference');
  late final _spine_attachment_dereference = _spine_attachment_dereferencePtr
      .asFunction<void Function(spine_attachment)>();

  spine_rtti spine_attachment_rtti() {
    return _spine_attachment_rtti();
  }

  late final _spine_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_attachment_rtti');
  late final _spine_attachment_rtti =
      _spine_attachment_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_attachment_loader_dispose(
    spine_attachment_loader self,
  ) {
    return _spine_attachment_loader_dispose(
      self,
    );
  }

  late final _spine_attachment_loader_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_attachment_loader)>>(
          'spine_attachment_loader_dispose');
  late final _spine_attachment_loader_dispose =
      _spine_attachment_loader_disposePtr
          .asFunction<void Function(spine_attachment_loader)>();

  spine_region_attachment spine_attachment_loader_new_region_attachment(
    spine_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
    ffi.Pointer<ffi.Char> path,
    spine_sequence sequence,
  ) {
    return _spine_attachment_loader_new_region_attachment(
      self,
      skin,
      name,
      path,
      sequence,
    );
  }

  late final _spine_attachment_loader_new_region_attachmentPtr = _lookup<
          ffi.NativeFunction<
              spine_region_attachment Function(
                  spine_attachment_loader,
                  spine_skin,
                  ffi.Pointer<ffi.Char>,
                  ffi.Pointer<ffi.Char>,
                  spine_sequence)>>(
      'spine_attachment_loader_new_region_attachment');
  late final _spine_attachment_loader_new_region_attachment =
      _spine_attachment_loader_new_region_attachmentPtr.asFunction<
          spine_region_attachment Function(spine_attachment_loader, spine_skin,
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, spine_sequence)>();

  spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(
    spine_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
    ffi.Pointer<ffi.Char> path,
    spine_sequence sequence,
  ) {
    return _spine_attachment_loader_new_mesh_attachment(
      self,
      skin,
      name,
      path,
      sequence,
    );
  }

  late final _spine_attachment_loader_new_mesh_attachmentPtr = _lookup<
      ffi.NativeFunction<
          spine_mesh_attachment Function(
              spine_attachment_loader,
              spine_skin,
              ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>,
              spine_sequence)>>('spine_attachment_loader_new_mesh_attachment');
  late final _spine_attachment_loader_new_mesh_attachment =
      _spine_attachment_loader_new_mesh_attachmentPtr.asFunction<
          spine_mesh_attachment Function(spine_attachment_loader, spine_skin,
              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, spine_sequence)>();

  spine_bounding_box_attachment
      spine_attachment_loader_new_bounding_box_attachment(
    spine_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_attachment_loader_new_bounding_box_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_attachment_loader_new_bounding_box_attachmentPtr = _lookup<
          ffi.NativeFunction<
              spine_bounding_box_attachment Function(
                  spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>>(
      'spine_attachment_loader_new_bounding_box_attachment');
  late final _spine_attachment_loader_new_bounding_box_attachment =
      _spine_attachment_loader_new_bounding_box_attachmentPtr.asFunction<
          spine_bounding_box_attachment Function(
              spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_path_attachment spine_attachment_loader_new_path_attachment(
    spine_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_attachment_loader_new_path_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_attachment_loader_new_path_attachmentPtr = _lookup<
          ffi.NativeFunction<
              spine_path_attachment Function(
                  spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>>(
      'spine_attachment_loader_new_path_attachment');
  late final _spine_attachment_loader_new_path_attachment =
      _spine_attachment_loader_new_path_attachmentPtr.asFunction<
          spine_path_attachment Function(
              spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_point_attachment spine_attachment_loader_new_point_attachment(
    spine_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_attachment_loader_new_point_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_attachment_loader_new_point_attachmentPtr = _lookup<
          ffi.NativeFunction<
              spine_point_attachment Function(
                  spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>>(
      'spine_attachment_loader_new_point_attachment');
  late final _spine_attachment_loader_new_point_attachment =
      _spine_attachment_loader_new_point_attachmentPtr.asFunction<
          spine_point_attachment Function(
              spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(
    spine_attachment_loader self,
    spine_skin skin,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_attachment_loader_new_clipping_attachment(
      self,
      skin,
      name,
    );
  }

  late final _spine_attachment_loader_new_clipping_attachmentPtr = _lookup<
          ffi.NativeFunction<
              spine_clipping_attachment Function(
                  spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>>(
      'spine_attachment_loader_new_clipping_attachment');
  late final _spine_attachment_loader_new_clipping_attachment =
      _spine_attachment_loader_new_clipping_attachmentPtr.asFunction<
          spine_clipping_attachment Function(
              spine_attachment_loader, spine_skin, ffi.Pointer<ffi.Char>)>();

  spine_attachment_timeline spine_attachment_timeline_create(
    int frameCount,
    int slotIndex,
  ) {
    return _spine_attachment_timeline_create(
      frameCount,
      slotIndex,
    );
  }

  late final _spine_attachment_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_attachment_timeline Function(
              ffi.Size, ffi.Int)>>('spine_attachment_timeline_create');
  late final _spine_attachment_timeline_create =
      _spine_attachment_timeline_createPtr
          .asFunction<spine_attachment_timeline Function(int, int)>();

  void spine_attachment_timeline_dispose(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_dispose(
      self,
    );
  }

  late final _spine_attachment_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_attachment_timeline)>>(
          'spine_attachment_timeline_dispose');
  late final _spine_attachment_timeline_dispose =
      _spine_attachment_timeline_disposePtr
          .asFunction<void Function(spine_attachment_timeline)>();

  spine_rtti spine_attachment_timeline_get_rtti(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_rtti(
      self,
    );
  }

  late final _spine_attachment_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_attachment_timeline)>>(
      'spine_attachment_timeline_get_rtti');
  late final _spine_attachment_timeline_get_rtti =
      _spine_attachment_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_attachment_timeline)>();

  void spine_attachment_timeline_apply(
    spine_attachment_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_attachment_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_attachment_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_attachment_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_attachment_timeline_apply');
  late final _spine_attachment_timeline_apply =
      _spine_attachment_timeline_applyPtr.asFunction<
          void Function(spine_attachment_timeline, spine_skeleton, double,
              double, spine_array_event, double, int, int, bool)>();

  void spine_attachment_timeline_set_frame(
    spine_attachment_timeline self,
    int frame,
    double time,
    ffi.Pointer<ffi.Char> attachmentName,
  ) {
    return _spine_attachment_timeline_set_frame(
      self,
      frame,
      time,
      attachmentName,
    );
  }

  late final _spine_attachment_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_attachment_timeline, ffi.Int, ffi.Float,
              ffi.Pointer<ffi.Char>)>>('spine_attachment_timeline_set_frame');
  late final _spine_attachment_timeline_set_frame =
      _spine_attachment_timeline_set_framePtr.asFunction<
          void Function(
              spine_attachment_timeline, int, double, ffi.Pointer<ffi.Char>)>();

  int spine_attachment_timeline_get_frame_entries(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_attachment_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_attachment_timeline)>>(
          'spine_attachment_timeline_get_frame_entries');
  late final _spine_attachment_timeline_get_frame_entries =
      _spine_attachment_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_attachment_timeline)>();

  int spine_attachment_timeline_get_frame_count(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_attachment_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_attachment_timeline)>>(
          'spine_attachment_timeline_get_frame_count');
  late final _spine_attachment_timeline_get_frame_count =
      _spine_attachment_timeline_get_frame_countPtr
          .asFunction<int Function(spine_attachment_timeline)>();

  spine_array_float spine_attachment_timeline_get_frames(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_frames(
      self,
    );
  }

  late final _spine_attachment_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_attachment_timeline)>>(
      'spine_attachment_timeline_get_frames');
  late final _spine_attachment_timeline_get_frames =
      _spine_attachment_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_attachment_timeline)>();

  double spine_attachment_timeline_get_duration(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_duration(
      self,
    );
  }

  late final _spine_attachment_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_attachment_timeline)>>(
      'spine_attachment_timeline_get_duration');
  late final _spine_attachment_timeline_get_duration =
      _spine_attachment_timeline_get_durationPtr
          .asFunction<double Function(spine_attachment_timeline)>();

  spine_array_property_id spine_attachment_timeline_get_property_ids(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_attachment_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_attachment_timeline)>>(
      'spine_attachment_timeline_get_property_ids');
  late final _spine_attachment_timeline_get_property_ids =
      _spine_attachment_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_attachment_timeline)>();

  int spine_attachment_timeline_get_slot_index(
    spine_attachment_timeline self,
  ) {
    return _spine_attachment_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_attachment_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_attachment_timeline)>>(
          'spine_attachment_timeline_get_slot_index');
  late final _spine_attachment_timeline_get_slot_index =
      _spine_attachment_timeline_get_slot_indexPtr
          .asFunction<int Function(spine_attachment_timeline)>();

  void spine_attachment_timeline_set_slot_index(
    spine_attachment_timeline self,
    int inValue,
  ) {
    return _spine_attachment_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_attachment_timeline_set_slot_indexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_attachment_timeline,
              ffi.Int)>>('spine_attachment_timeline_set_slot_index');
  late final _spine_attachment_timeline_set_slot_index =
      _spine_attachment_timeline_set_slot_indexPtr
          .asFunction<void Function(spine_attachment_timeline, int)>();

  spine_rtti spine_attachment_timeline_rtti() {
    return _spine_attachment_timeline_rtti();
  }

  late final _spine_attachment_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_attachment_timeline_rtti');
  late final _spine_attachment_timeline_rtti =
      _spine_attachment_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_bone spine_bone_create(
    spine_bone_data data,
    spine_bone parent,
  ) {
    return _spine_bone_create(
      data,
      parent,
    );
  }

  late final _spine_bone_createPtr = _lookup<
          ffi.NativeFunction<spine_bone Function(spine_bone_data, spine_bone)>>(
      'spine_bone_create');
  late final _spine_bone_create = _spine_bone_createPtr
      .asFunction<spine_bone Function(spine_bone_data, spine_bone)>();

  spine_bone spine_bone_create2(
    spine_bone bone,
    spine_bone parent,
  ) {
    return _spine_bone_create2(
      bone,
      parent,
    );
  }

  late final _spine_bone_create2Ptr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_bone, spine_bone)>>(
          'spine_bone_create2');
  late final _spine_bone_create2 = _spine_bone_create2Ptr
      .asFunction<spine_bone Function(spine_bone, spine_bone)>();

  void spine_bone_dispose(
    spine_bone self,
  ) {
    return _spine_bone_dispose(
      self,
    );
  }

  late final _spine_bone_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>(
          'spine_bone_dispose');
  late final _spine_bone_dispose =
      _spine_bone_disposePtr.asFunction<void Function(spine_bone)>();

  spine_rtti spine_bone_get_rtti(
    spine_bone self,
  ) {
    return _spine_bone_get_rtti(
      self,
    );
  }

  late final _spine_bone_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_bone)>>(
          'spine_bone_get_rtti');
  late final _spine_bone_get_rtti =
      _spine_bone_get_rttiPtr.asFunction<spine_rtti Function(spine_bone)>();

  spine_bone spine_bone_get_parent(
    spine_bone self,
  ) {
    return _spine_bone_get_parent(
      self,
    );
  }

  late final _spine_bone_get_parentPtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_bone)>>(
          'spine_bone_get_parent');
  late final _spine_bone_get_parent =
      _spine_bone_get_parentPtr.asFunction<spine_bone Function(spine_bone)>();

  spine_array_bone spine_bone_get_children(
    spine_bone self,
  ) {
    return _spine_bone_get_children(
      self,
    );
  }

  late final _spine_bone_get_childrenPtr =
      _lookup<ffi.NativeFunction<spine_array_bone Function(spine_bone)>>(
          'spine_bone_get_children');
  late final _spine_bone_get_children = _spine_bone_get_childrenPtr
      .asFunction<spine_array_bone Function(spine_bone)>();

  bool spine_bone_is_y_down() {
    return _spine_bone_is_y_down();
  }

  late final _spine_bone_is_y_downPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function()>>('spine_bone_is_y_down');
  late final _spine_bone_is_y_down =
      _spine_bone_is_y_downPtr.asFunction<bool Function()>();

  void spine_bone_set_y_down(
    bool value,
  ) {
    return _spine_bone_set_y_down(
      value,
    );
  }

  late final _spine_bone_set_y_downPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Bool)>>(
          'spine_bone_set_y_down');
  late final _spine_bone_set_y_down =
      _spine_bone_set_y_downPtr.asFunction<void Function(bool)>();

  void spine_bone_update(
    spine_bone self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_bone_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_bone_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_bone, spine_skeleton, ffi.Int32)>>('spine_bone_update');
  late final _spine_bone_update = _spine_bone_updatePtr
      .asFunction<void Function(spine_bone, spine_skeleton, int)>();

  spine_bone_data spine_bone_get_data(
    spine_bone self,
  ) {
    return _spine_bone_get_data(
      self,
    );
  }

  late final _spine_bone_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_bone)>>(
          'spine_bone_get_data');
  late final _spine_bone_get_data = _spine_bone_get_dataPtr
      .asFunction<spine_bone_data Function(spine_bone)>();

  spine_bone_local spine_bone_get_pose(
    spine_bone self,
  ) {
    return _spine_bone_get_pose(
      self,
    );
  }

  late final _spine_bone_get_posePtr =
      _lookup<ffi.NativeFunction<spine_bone_local Function(spine_bone)>>(
          'spine_bone_get_pose');
  late final _spine_bone_get_pose = _spine_bone_get_posePtr
      .asFunction<spine_bone_local Function(spine_bone)>();

  spine_bone_pose spine_bone_get_applied_pose(
    spine_bone self,
  ) {
    return _spine_bone_get_applied_pose(
      self,
    );
  }

  late final _spine_bone_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_bone_pose Function(spine_bone)>>(
          'spine_bone_get_applied_pose');
  late final _spine_bone_get_applied_pose = _spine_bone_get_applied_posePtr
      .asFunction<spine_bone_pose Function(spine_bone)>();

  void spine_bone_reset_constrained(
    spine_bone self,
  ) {
    return _spine_bone_reset_constrained(
      self,
    );
  }

  late final _spine_bone_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>(
          'spine_bone_reset_constrained');
  late final _spine_bone_reset_constrained =
      _spine_bone_reset_constrainedPtr.asFunction<void Function(spine_bone)>();

  void spine_bone_constrained(
    spine_bone self,
  ) {
    return _spine_bone_constrained(
      self,
    );
  }

  late final _spine_bone_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>(
          'spine_bone_constrained');
  late final _spine_bone_constrained =
      _spine_bone_constrainedPtr.asFunction<void Function(spine_bone)>();

  bool spine_bone_is_pose_equal_to_applied(
    spine_bone self,
  ) {
    return _spine_bone_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_bone_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_bone)>>(
          'spine_bone_is_pose_equal_to_applied');
  late final _spine_bone_is_pose_equal_to_applied =
      _spine_bone_is_pose_equal_to_appliedPtr
          .asFunction<bool Function(spine_bone)>();

  bool spine_bone_is_active(
    spine_bone self,
  ) {
    return _spine_bone_is_active(
      self,
    );
  }

  late final _spine_bone_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_bone)>>(
          'spine_bone_is_active');
  late final _spine_bone_is_active =
      _spine_bone_is_activePtr.asFunction<bool Function(spine_bone)>();

  void spine_bone_set_active(
    spine_bone self,
    bool active,
  ) {
    return _spine_bone_set_active(
      self,
      active,
    );
  }

  late final _spine_bone_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Bool)>>(
          'spine_bone_set_active');
  late final _spine_bone_set_active =
      _spine_bone_set_activePtr.asFunction<void Function(spine_bone, bool)>();

  spine_rtti spine_bone_rtti() {
    return _spine_bone_rtti();
  }

  late final _spine_bone_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_bone_rtti');
  late final _spine_bone_rtti =
      _spine_bone_rttiPtr.asFunction<spine_rtti Function()>();

  spine_bone_data spine_bone_data_create(
    int index,
    ffi.Pointer<ffi.Char> name,
    spine_bone_data parent,
  ) {
    return _spine_bone_data_create(
      index,
      name,
      parent,
    );
  }

  late final _spine_bone_data_createPtr = _lookup<
      ffi.NativeFunction<
          spine_bone_data Function(ffi.Int, ffi.Pointer<ffi.Char>,
              spine_bone_data)>>('spine_bone_data_create');
  late final _spine_bone_data_create = _spine_bone_data_createPtr.asFunction<
      spine_bone_data Function(int, ffi.Pointer<ffi.Char>, spine_bone_data)>();

  void spine_bone_data_dispose(
    spine_bone_data self,
  ) {
    return _spine_bone_data_dispose(
      self,
    );
  }

  late final _spine_bone_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data)>>(
          'spine_bone_data_dispose');
  late final _spine_bone_data_dispose =
      _spine_bone_data_disposePtr.asFunction<void Function(spine_bone_data)>();

  int spine_bone_data_get_index(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_index(
      self,
    );
  }

  late final _spine_bone_data_get_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_bone_data)>>(
          'spine_bone_data_get_index');
  late final _spine_bone_data_get_index =
      _spine_bone_data_get_indexPtr.asFunction<int Function(spine_bone_data)>();

  spine_bone_data spine_bone_data_get_parent(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_parent(
      self,
    );
  }

  late final _spine_bone_data_get_parentPtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_bone_data)>>(
          'spine_bone_data_get_parent');
  late final _spine_bone_data_get_parent = _spine_bone_data_get_parentPtr
      .asFunction<spine_bone_data Function(spine_bone_data)>();

  double spine_bone_data_get_length(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_length(
      self,
    );
  }

  late final _spine_bone_data_get_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
          'spine_bone_data_get_length');
  late final _spine_bone_data_get_length = _spine_bone_data_get_lengthPtr
      .asFunction<double Function(spine_bone_data)>();

  void spine_bone_data_set_length(
    spine_bone_data self,
    double inValue,
  ) {
    return _spine_bone_data_set_length(
      self,
      inValue,
    );
  }

  late final _spine_bone_data_set_lengthPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>(
      'spine_bone_data_set_length');
  late final _spine_bone_data_set_length = _spine_bone_data_set_lengthPtr
      .asFunction<void Function(spine_bone_data, double)>();

  spine_color spine_bone_data_get_color(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_color(
      self,
    );
  }

  late final _spine_bone_data_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_bone_data)>>(
          'spine_bone_data_get_color');
  late final _spine_bone_data_get_color = _spine_bone_data_get_colorPtr
      .asFunction<spine_color Function(spine_bone_data)>();

  ffi.Pointer<ffi.Char> spine_bone_data_get_icon(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_icon(
      self,
    );
  }

  late final _spine_bone_data_get_iconPtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_bone_data)>>(
      'spine_bone_data_get_icon');
  late final _spine_bone_data_get_icon = _spine_bone_data_get_iconPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_bone_data)>();

  void spine_bone_data_set_icon(
    spine_bone_data self,
    ffi.Pointer<ffi.Char> icon,
  ) {
    return _spine_bone_data_set_icon(
      self,
      icon,
    );
  }

  late final _spine_bone_data_set_iconPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_data,
              ffi.Pointer<ffi.Char>)>>('spine_bone_data_set_icon');
  late final _spine_bone_data_set_icon = _spine_bone_data_set_iconPtr
      .asFunction<void Function(spine_bone_data, ffi.Pointer<ffi.Char>)>();

  bool spine_bone_data_get_visible(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_visible(
      self,
    );
  }

  late final _spine_bone_data_get_visiblePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_bone_data)>>(
          'spine_bone_data_get_visible');
  late final _spine_bone_data_get_visible = _spine_bone_data_get_visiblePtr
      .asFunction<bool Function(spine_bone_data)>();

  void spine_bone_data_set_visible(
    spine_bone_data self,
    bool inValue,
  ) {
    return _spine_bone_data_set_visible(
      self,
      inValue,
    );
  }

  late final _spine_bone_data_set_visiblePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Bool)>>(
          'spine_bone_data_set_visible');
  late final _spine_bone_data_set_visible = _spine_bone_data_set_visiblePtr
      .asFunction<void Function(spine_bone_data, bool)>();

  spine_bone_local spine_bone_data_get_setup_pose(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_setup_pose(
      self,
    );
  }

  late final _spine_bone_data_get_setup_posePtr =
      _lookup<ffi.NativeFunction<spine_bone_local Function(spine_bone_data)>>(
          'spine_bone_data_get_setup_pose');
  late final _spine_bone_data_get_setup_pose =
      _spine_bone_data_get_setup_posePtr
          .asFunction<spine_bone_local Function(spine_bone_data)>();

  ffi.Pointer<ffi.Char> spine_bone_data_get_name(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_name(
      self,
    );
  }

  late final _spine_bone_data_get_namePtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_bone_data)>>(
      'spine_bone_data_get_name');
  late final _spine_bone_data_get_name = _spine_bone_data_get_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_bone_data)>();

  bool spine_bone_data_get_skin_required(
    spine_bone_data self,
  ) {
    return _spine_bone_data_get_skin_required(
      self,
    );
  }

  late final _spine_bone_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_bone_data)>>(
          'spine_bone_data_get_skin_required');
  late final _spine_bone_data_get_skin_required =
      _spine_bone_data_get_skin_requiredPtr
          .asFunction<bool Function(spine_bone_data)>();

  void spine_bone_data_set_skin_required(
    spine_bone_data self,
    bool skinRequired,
  ) {
    return _spine_bone_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_bone_data_set_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Bool)>>(
          'spine_bone_data_set_skin_required');
  late final _spine_bone_data_set_skin_required =
      _spine_bone_data_set_skin_requiredPtr
          .asFunction<void Function(spine_bone_data, bool)>();

  spine_bone_local spine_bone_local_create() {
    return _spine_bone_local_create();
  }

  late final _spine_bone_local_createPtr =
      _lookup<ffi.NativeFunction<spine_bone_local Function()>>(
          'spine_bone_local_create');
  late final _spine_bone_local_create =
      _spine_bone_local_createPtr.asFunction<spine_bone_local Function()>();

  void spine_bone_local_dispose(
    spine_bone_local self,
  ) {
    return _spine_bone_local_dispose(
      self,
    );
  }

  late final _spine_bone_local_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_local)>>(
          'spine_bone_local_dispose');
  late final _spine_bone_local_dispose = _spine_bone_local_disposePtr
      .asFunction<void Function(spine_bone_local)>();

  void spine_bone_local_set(
    spine_bone_local self,
    spine_bone_local pose,
  ) {
    return _spine_bone_local_set(
      self,
      pose,
    );
  }

  late final _spine_bone_local_setPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_bone_local, spine_bone_local)>>('spine_bone_local_set');
  late final _spine_bone_local_set = _spine_bone_local_setPtr
      .asFunction<void Function(spine_bone_local, spine_bone_local)>();

  double spine_bone_local_get_x(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_x(
      self,
    );
  }

  late final _spine_bone_local_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>(
          'spine_bone_local_get_x');
  late final _spine_bone_local_get_x = _spine_bone_local_get_xPtr
      .asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_x(
    spine_bone_local self,
    double x,
  ) {
    return _spine_bone_local_set_x(
      self,
      x,
    );
  }

  late final _spine_bone_local_set_xPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>(
      'spine_bone_local_set_x');
  late final _spine_bone_local_set_x = _spine_bone_local_set_xPtr
      .asFunction<void Function(spine_bone_local, double)>();

  double spine_bone_local_get_y(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_y(
      self,
    );
  }

  late final _spine_bone_local_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>(
          'spine_bone_local_get_y');
  late final _spine_bone_local_get_y = _spine_bone_local_get_yPtr
      .asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_y(
    spine_bone_local self,
    double y,
  ) {
    return _spine_bone_local_set_y(
      self,
      y,
    );
  }

  late final _spine_bone_local_set_yPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>(
      'spine_bone_local_set_y');
  late final _spine_bone_local_set_y = _spine_bone_local_set_yPtr
      .asFunction<void Function(spine_bone_local, double)>();

  void spine_bone_local_set_position(
    spine_bone_local self,
    double x,
    double y,
  ) {
    return _spine_bone_local_set_position(
      self,
      x,
      y,
    );
  }

  late final _spine_bone_local_set_positionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_local, ffi.Float,
              ffi.Float)>>('spine_bone_local_set_position');
  late final _spine_bone_local_set_position = _spine_bone_local_set_positionPtr
      .asFunction<void Function(spine_bone_local, double, double)>();

  double spine_bone_local_get_rotation(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_rotation(
      self,
    );
  }

  late final _spine_bone_local_get_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>(
          'spine_bone_local_get_rotation');
  late final _spine_bone_local_get_rotation = _spine_bone_local_get_rotationPtr
      .asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_rotation(
    spine_bone_local self,
    double rotation,
  ) {
    return _spine_bone_local_set_rotation(
      self,
      rotation,
    );
  }

  late final _spine_bone_local_set_rotationPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>(
      'spine_bone_local_set_rotation');
  late final _spine_bone_local_set_rotation = _spine_bone_local_set_rotationPtr
      .asFunction<void Function(spine_bone_local, double)>();

  double spine_bone_local_get_scale_x(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_scale_x(
      self,
    );
  }

  late final _spine_bone_local_get_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>(
          'spine_bone_local_get_scale_x');
  late final _spine_bone_local_get_scale_x = _spine_bone_local_get_scale_xPtr
      .asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_scale_x(
    spine_bone_local self,
    double scaleX,
  ) {
    return _spine_bone_local_set_scale_x(
      self,
      scaleX,
    );
  }

  late final _spine_bone_local_set_scale_xPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>(
      'spine_bone_local_set_scale_x');
  late final _spine_bone_local_set_scale_x = _spine_bone_local_set_scale_xPtr
      .asFunction<void Function(spine_bone_local, double)>();

  double spine_bone_local_get_scale_y(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_scale_y(
      self,
    );
  }

  late final _spine_bone_local_get_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>(
          'spine_bone_local_get_scale_y');
  late final _spine_bone_local_get_scale_y = _spine_bone_local_get_scale_yPtr
      .asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_scale_y(
    spine_bone_local self,
    double scaleY,
  ) {
    return _spine_bone_local_set_scale_y(
      self,
      scaleY,
    );
  }

  late final _spine_bone_local_set_scale_yPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>(
      'spine_bone_local_set_scale_y');
  late final _spine_bone_local_set_scale_y = _spine_bone_local_set_scale_yPtr
      .asFunction<void Function(spine_bone_local, double)>();

  void spine_bone_local_set_scale_1(
    spine_bone_local self,
    double scaleX,
    double scaleY,
  ) {
    return _spine_bone_local_set_scale_1(
      self,
      scaleX,
      scaleY,
    );
  }

  late final _spine_bone_local_set_scale_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_local, ffi.Float,
              ffi.Float)>>('spine_bone_local_set_scale_1');
  late final _spine_bone_local_set_scale_1 = _spine_bone_local_set_scale_1Ptr
      .asFunction<void Function(spine_bone_local, double, double)>();

  void spine_bone_local_set_scale_2(
    spine_bone_local self,
    double scale,
  ) {
    return _spine_bone_local_set_scale_2(
      self,
      scale,
    );
  }

  late final _spine_bone_local_set_scale_2Ptr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>(
      'spine_bone_local_set_scale_2');
  late final _spine_bone_local_set_scale_2 = _spine_bone_local_set_scale_2Ptr
      .asFunction<void Function(spine_bone_local, double)>();

  double spine_bone_local_get_shear_x(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_shear_x(
      self,
    );
  }

  late final _spine_bone_local_get_shear_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>(
          'spine_bone_local_get_shear_x');
  late final _spine_bone_local_get_shear_x = _spine_bone_local_get_shear_xPtr
      .asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_shear_x(
    spine_bone_local self,
    double shearX,
  ) {
    return _spine_bone_local_set_shear_x(
      self,
      shearX,
    );
  }

  late final _spine_bone_local_set_shear_xPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>(
      'spine_bone_local_set_shear_x');
  late final _spine_bone_local_set_shear_x = _spine_bone_local_set_shear_xPtr
      .asFunction<void Function(spine_bone_local, double)>();

  double spine_bone_local_get_shear_y(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_shear_y(
      self,
    );
  }

  late final _spine_bone_local_get_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_local)>>(
          'spine_bone_local_get_shear_y');
  late final _spine_bone_local_get_shear_y = _spine_bone_local_get_shear_yPtr
      .asFunction<double Function(spine_bone_local)>();

  void spine_bone_local_set_shear_y(
    spine_bone_local self,
    double shearY,
  ) {
    return _spine_bone_local_set_shear_y(
      self,
      shearY,
    );
  }

  late final _spine_bone_local_set_shear_yPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Float)>>(
      'spine_bone_local_set_shear_y');
  late final _spine_bone_local_set_shear_y = _spine_bone_local_set_shear_yPtr
      .asFunction<void Function(spine_bone_local, double)>();

  int spine_bone_local_get_inherit(
    spine_bone_local self,
  ) {
    return _spine_bone_local_get_inherit(
      self,
    );
  }

  late final _spine_bone_local_get_inheritPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_bone_local)>>(
          'spine_bone_local_get_inherit');
  late final _spine_bone_local_get_inherit = _spine_bone_local_get_inheritPtr
      .asFunction<int Function(spine_bone_local)>();

  void spine_bone_local_set_inherit(
    spine_bone_local self,
    int inherit,
  ) {
    return _spine_bone_local_set_inherit(
      self,
      inherit,
    );
  }

  late final _spine_bone_local_set_inheritPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_local, ffi.Int32)>>(
      'spine_bone_local_set_inherit');
  late final _spine_bone_local_set_inherit = _spine_bone_local_set_inheritPtr
      .asFunction<void Function(spine_bone_local, int)>();

  spine_bone_pose spine_bone_pose_create() {
    return _spine_bone_pose_create();
  }

  late final _spine_bone_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_bone_pose Function()>>(
          'spine_bone_pose_create');
  late final _spine_bone_pose_create =
      _spine_bone_pose_createPtr.asFunction<spine_bone_pose Function()>();

  void spine_bone_pose_dispose(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_dispose(
      self,
    );
  }

  late final _spine_bone_pose_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose)>>(
          'spine_bone_pose_dispose');
  late final _spine_bone_pose_dispose =
      _spine_bone_pose_disposePtr.asFunction<void Function(spine_bone_pose)>();

  spine_rtti spine_bone_pose_get_rtti(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_rtti(
      self,
    );
  }

  late final _spine_bone_pose_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_bone_pose)>>(
          'spine_bone_pose_get_rtti');
  late final _spine_bone_pose_get_rtti = _spine_bone_pose_get_rttiPtr
      .asFunction<spine_rtti Function(spine_bone_pose)>();

  void spine_bone_pose_update(
    spine_bone_pose self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_bone_pose_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_bone_pose_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_pose, spine_skeleton,
              ffi.Int32)>>('spine_bone_pose_update');
  late final _spine_bone_pose_update = _spine_bone_pose_updatePtr
      .asFunction<void Function(spine_bone_pose, spine_skeleton, int)>();

  void spine_bone_pose_update_world_transform(
    spine_bone_pose self,
    spine_skeleton skeleton,
  ) {
    return _spine_bone_pose_update_world_transform(
      self,
      skeleton,
    );
  }

  late final _spine_bone_pose_update_world_transformPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_bone_pose, spine_skeleton)>>(
      'spine_bone_pose_update_world_transform');
  late final _spine_bone_pose_update_world_transform =
      _spine_bone_pose_update_world_transformPtr
          .asFunction<void Function(spine_bone_pose, spine_skeleton)>();

  void spine_bone_pose_update_local_transform(
    spine_bone_pose self,
    spine_skeleton skeleton,
  ) {
    return _spine_bone_pose_update_local_transform(
      self,
      skeleton,
    );
  }

  late final _spine_bone_pose_update_local_transformPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_bone_pose, spine_skeleton)>>(
      'spine_bone_pose_update_local_transform');
  late final _spine_bone_pose_update_local_transform =
      _spine_bone_pose_update_local_transformPtr
          .asFunction<void Function(spine_bone_pose, spine_skeleton)>();

  void spine_bone_pose_validate_local_transform(
    spine_bone_pose self,
    spine_skeleton skeleton,
  ) {
    return _spine_bone_pose_validate_local_transform(
      self,
      skeleton,
    );
  }

  late final _spine_bone_pose_validate_local_transformPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_bone_pose, spine_skeleton)>>(
      'spine_bone_pose_validate_local_transform');
  late final _spine_bone_pose_validate_local_transform =
      _spine_bone_pose_validate_local_transformPtr
          .asFunction<void Function(spine_bone_pose, spine_skeleton)>();

  void spine_bone_pose_modify_local(
    spine_bone_pose self,
    spine_skeleton skeleton,
  ) {
    return _spine_bone_pose_modify_local(
      self,
      skeleton,
    );
  }

  late final _spine_bone_pose_modify_localPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_bone_pose, spine_skeleton)>>(
      'spine_bone_pose_modify_local');
  late final _spine_bone_pose_modify_local = _spine_bone_pose_modify_localPtr
      .asFunction<void Function(spine_bone_pose, spine_skeleton)>();

  void spine_bone_pose_modify_world(
    spine_bone_pose self,
    int update,
  ) {
    return _spine_bone_pose_modify_world(
      self,
      update,
    );
  }

  late final _spine_bone_pose_modify_worldPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Int)>>(
          'spine_bone_pose_modify_world');
  late final _spine_bone_pose_modify_world = _spine_bone_pose_modify_worldPtr
      .asFunction<void Function(spine_bone_pose, int)>();

  void spine_bone_pose_reset_world(
    spine_bone_pose self,
    int update,
  ) {
    return _spine_bone_pose_reset_world(
      self,
      update,
    );
  }

  late final _spine_bone_pose_reset_worldPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Int)>>(
          'spine_bone_pose_reset_world');
  late final _spine_bone_pose_reset_world = _spine_bone_pose_reset_worldPtr
      .asFunction<void Function(spine_bone_pose, int)>();

  double spine_bone_pose_get_a(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_a(
      self,
    );
  }

  late final _spine_bone_pose_get_aPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_a');
  late final _spine_bone_pose_get_a =
      _spine_bone_pose_get_aPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_a(
    spine_bone_pose self,
    double a,
  ) {
    return _spine_bone_pose_set_a(
      self,
      a,
    );
  }

  late final _spine_bone_pose_set_aPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_a');
  late final _spine_bone_pose_set_a = _spine_bone_pose_set_aPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  double spine_bone_pose_get_b(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_b(
      self,
    );
  }

  late final _spine_bone_pose_get_bPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_b');
  late final _spine_bone_pose_get_b =
      _spine_bone_pose_get_bPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_b(
    spine_bone_pose self,
    double b,
  ) {
    return _spine_bone_pose_set_b(
      self,
      b,
    );
  }

  late final _spine_bone_pose_set_bPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_b');
  late final _spine_bone_pose_set_b = _spine_bone_pose_set_bPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  double spine_bone_pose_get_c(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_c(
      self,
    );
  }

  late final _spine_bone_pose_get_cPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_c');
  late final _spine_bone_pose_get_c =
      _spine_bone_pose_get_cPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_c(
    spine_bone_pose self,
    double c,
  ) {
    return _spine_bone_pose_set_c(
      self,
      c,
    );
  }

  late final _spine_bone_pose_set_cPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_c');
  late final _spine_bone_pose_set_c = _spine_bone_pose_set_cPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  double spine_bone_pose_get_d(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_d(
      self,
    );
  }

  late final _spine_bone_pose_get_dPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_d');
  late final _spine_bone_pose_get_d =
      _spine_bone_pose_get_dPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_d(
    spine_bone_pose self,
    double d,
  ) {
    return _spine_bone_pose_set_d(
      self,
      d,
    );
  }

  late final _spine_bone_pose_set_dPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_d');
  late final _spine_bone_pose_set_d = _spine_bone_pose_set_dPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  double spine_bone_pose_get_world_x(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_world_x(
      self,
    );
  }

  late final _spine_bone_pose_get_world_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_world_x');
  late final _spine_bone_pose_get_world_x = _spine_bone_pose_get_world_xPtr
      .asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_world_x(
    spine_bone_pose self,
    double worldX,
  ) {
    return _spine_bone_pose_set_world_x(
      self,
      worldX,
    );
  }

  late final _spine_bone_pose_set_world_xPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_world_x');
  late final _spine_bone_pose_set_world_x = _spine_bone_pose_set_world_xPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  double spine_bone_pose_get_world_y(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_world_y(
      self,
    );
  }

  late final _spine_bone_pose_get_world_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_world_y');
  late final _spine_bone_pose_get_world_y = _spine_bone_pose_get_world_yPtr
      .asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_world_y(
    spine_bone_pose self,
    double worldY,
  ) {
    return _spine_bone_pose_set_world_y(
      self,
      worldY,
    );
  }

  late final _spine_bone_pose_set_world_yPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_world_y');
  late final _spine_bone_pose_set_world_y = _spine_bone_pose_set_world_yPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  double spine_bone_pose_get_world_rotation_x(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_world_rotation_x(
      self,
    );
  }

  late final _spine_bone_pose_get_world_rotation_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_world_rotation_x');
  late final _spine_bone_pose_get_world_rotation_x =
      _spine_bone_pose_get_world_rotation_xPtr
          .asFunction<double Function(spine_bone_pose)>();

  double spine_bone_pose_get_world_rotation_y(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_world_rotation_y(
      self,
    );
  }

  late final _spine_bone_pose_get_world_rotation_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_world_rotation_y');
  late final _spine_bone_pose_get_world_rotation_y =
      _spine_bone_pose_get_world_rotation_yPtr
          .asFunction<double Function(spine_bone_pose)>();

  double spine_bone_pose_get_world_scale_x(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_world_scale_x(
      self,
    );
  }

  late final _spine_bone_pose_get_world_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_world_scale_x');
  late final _spine_bone_pose_get_world_scale_x =
      _spine_bone_pose_get_world_scale_xPtr
          .asFunction<double Function(spine_bone_pose)>();

  double spine_bone_pose_get_world_scale_y(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_world_scale_y(
      self,
    );
  }

  late final _spine_bone_pose_get_world_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_world_scale_y');
  late final _spine_bone_pose_get_world_scale_y =
      _spine_bone_pose_get_world_scale_yPtr
          .asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_world_to_local(
    spine_bone_pose self,
    double worldX,
    double worldY,
    ffi.Pointer<ffi.Float> outLocalX,
    ffi.Pointer<ffi.Float> outLocalY,
  ) {
    return _spine_bone_pose_world_to_local(
      self,
      worldX,
      worldY,
      outLocalX,
      outLocalY,
    );
  }

  late final _spine_bone_pose_world_to_localPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_bone_pose,
              ffi.Float,
              ffi.Float,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>>('spine_bone_pose_world_to_local');
  late final _spine_bone_pose_world_to_local =
      _spine_bone_pose_world_to_localPtr.asFunction<
          void Function(spine_bone_pose, double, double, ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>();

  void spine_bone_pose_local_to_world(
    spine_bone_pose self,
    double localX,
    double localY,
    ffi.Pointer<ffi.Float> outWorldX,
    ffi.Pointer<ffi.Float> outWorldY,
  ) {
    return _spine_bone_pose_local_to_world(
      self,
      localX,
      localY,
      outWorldX,
      outWorldY,
    );
  }

  late final _spine_bone_pose_local_to_worldPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_bone_pose,
              ffi.Float,
              ffi.Float,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>>('spine_bone_pose_local_to_world');
  late final _spine_bone_pose_local_to_world =
      _spine_bone_pose_local_to_worldPtr.asFunction<
          void Function(spine_bone_pose, double, double, ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>();

  void spine_bone_pose_world_to_parent(
    spine_bone_pose self,
    double worldX,
    double worldY,
    ffi.Pointer<ffi.Float> outParentX,
    ffi.Pointer<ffi.Float> outParentY,
  ) {
    return _spine_bone_pose_world_to_parent(
      self,
      worldX,
      worldY,
      outParentX,
      outParentY,
    );
  }

  late final _spine_bone_pose_world_to_parentPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_bone_pose,
              ffi.Float,
              ffi.Float,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>>('spine_bone_pose_world_to_parent');
  late final _spine_bone_pose_world_to_parent =
      _spine_bone_pose_world_to_parentPtr.asFunction<
          void Function(spine_bone_pose, double, double, ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>();

  void spine_bone_pose_parent_to_world(
    spine_bone_pose self,
    double parentX,
    double parentY,
    ffi.Pointer<ffi.Float> outWorldX,
    ffi.Pointer<ffi.Float> outWorldY,
  ) {
    return _spine_bone_pose_parent_to_world(
      self,
      parentX,
      parentY,
      outWorldX,
      outWorldY,
    );
  }

  late final _spine_bone_pose_parent_to_worldPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_bone_pose,
              ffi.Float,
              ffi.Float,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>>('spine_bone_pose_parent_to_world');
  late final _spine_bone_pose_parent_to_world =
      _spine_bone_pose_parent_to_worldPtr.asFunction<
          void Function(spine_bone_pose, double, double, ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>)>();

  double spine_bone_pose_world_to_local_rotation(
    spine_bone_pose self,
    double worldRotation,
  ) {
    return _spine_bone_pose_world_to_local_rotation(
      self,
      worldRotation,
    );
  }

  late final _spine_bone_pose_world_to_local_rotationPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_world_to_local_rotation');
  late final _spine_bone_pose_world_to_local_rotation =
      _spine_bone_pose_world_to_local_rotationPtr
          .asFunction<double Function(spine_bone_pose, double)>();

  double spine_bone_pose_local_to_world_rotation(
    spine_bone_pose self,
    double localRotation,
  ) {
    return _spine_bone_pose_local_to_world_rotation(
      self,
      localRotation,
    );
  }

  late final _spine_bone_pose_local_to_world_rotationPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_local_to_world_rotation');
  late final _spine_bone_pose_local_to_world_rotation =
      _spine_bone_pose_local_to_world_rotationPtr
          .asFunction<double Function(spine_bone_pose, double)>();

  void spine_bone_pose_rotate_world(
    spine_bone_pose self,
    double degrees,
  ) {
    return _spine_bone_pose_rotate_world(
      self,
      degrees,
    );
  }

  late final _spine_bone_pose_rotate_worldPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_rotate_world');
  late final _spine_bone_pose_rotate_world = _spine_bone_pose_rotate_worldPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  void spine_bone_pose_set(
    spine_bone_pose self,
    spine_bone_local pose,
  ) {
    return _spine_bone_pose_set(
      self,
      pose,
    );
  }

  late final _spine_bone_pose_setPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_bone_pose, spine_bone_local)>>('spine_bone_pose_set');
  late final _spine_bone_pose_set = _spine_bone_pose_setPtr
      .asFunction<void Function(spine_bone_pose, spine_bone_local)>();

  double spine_bone_pose_get_x(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_x(
      self,
    );
  }

  late final _spine_bone_pose_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_x');
  late final _spine_bone_pose_get_x =
      _spine_bone_pose_get_xPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_x(
    spine_bone_pose self,
    double x,
  ) {
    return _spine_bone_pose_set_x(
      self,
      x,
    );
  }

  late final _spine_bone_pose_set_xPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_x');
  late final _spine_bone_pose_set_x = _spine_bone_pose_set_xPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  double spine_bone_pose_get_y(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_y(
      self,
    );
  }

  late final _spine_bone_pose_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_y');
  late final _spine_bone_pose_get_y =
      _spine_bone_pose_get_yPtr.asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_y(
    spine_bone_pose self,
    double y,
  ) {
    return _spine_bone_pose_set_y(
      self,
      y,
    );
  }

  late final _spine_bone_pose_set_yPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_y');
  late final _spine_bone_pose_set_y = _spine_bone_pose_set_yPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  void spine_bone_pose_set_position(
    spine_bone_pose self,
    double x,
    double y,
  ) {
    return _spine_bone_pose_set_position(
      self,
      x,
      y,
    );
  }

  late final _spine_bone_pose_set_positionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_pose, ffi.Float,
              ffi.Float)>>('spine_bone_pose_set_position');
  late final _spine_bone_pose_set_position = _spine_bone_pose_set_positionPtr
      .asFunction<void Function(spine_bone_pose, double, double)>();

  double spine_bone_pose_get_rotation(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_rotation(
      self,
    );
  }

  late final _spine_bone_pose_get_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_rotation');
  late final _spine_bone_pose_get_rotation = _spine_bone_pose_get_rotationPtr
      .asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_rotation(
    spine_bone_pose self,
    double rotation,
  ) {
    return _spine_bone_pose_set_rotation(
      self,
      rotation,
    );
  }

  late final _spine_bone_pose_set_rotationPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_rotation');
  late final _spine_bone_pose_set_rotation = _spine_bone_pose_set_rotationPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  double spine_bone_pose_get_scale_x(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_scale_x(
      self,
    );
  }

  late final _spine_bone_pose_get_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_scale_x');
  late final _spine_bone_pose_get_scale_x = _spine_bone_pose_get_scale_xPtr
      .asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_scale_x(
    spine_bone_pose self,
    double scaleX,
  ) {
    return _spine_bone_pose_set_scale_x(
      self,
      scaleX,
    );
  }

  late final _spine_bone_pose_set_scale_xPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_scale_x');
  late final _spine_bone_pose_set_scale_x = _spine_bone_pose_set_scale_xPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  double spine_bone_pose_get_scale_y(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_scale_y(
      self,
    );
  }

  late final _spine_bone_pose_get_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_scale_y');
  late final _spine_bone_pose_get_scale_y = _spine_bone_pose_get_scale_yPtr
      .asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_scale_y(
    spine_bone_pose self,
    double scaleY,
  ) {
    return _spine_bone_pose_set_scale_y(
      self,
      scaleY,
    );
  }

  late final _spine_bone_pose_set_scale_yPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_scale_y');
  late final _spine_bone_pose_set_scale_y = _spine_bone_pose_set_scale_yPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  void spine_bone_pose_set_scale_1(
    spine_bone_pose self,
    double scaleX,
    double scaleY,
  ) {
    return _spine_bone_pose_set_scale_1(
      self,
      scaleX,
      scaleY,
    );
  }

  late final _spine_bone_pose_set_scale_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_pose, ffi.Float,
              ffi.Float)>>('spine_bone_pose_set_scale_1');
  late final _spine_bone_pose_set_scale_1 = _spine_bone_pose_set_scale_1Ptr
      .asFunction<void Function(spine_bone_pose, double, double)>();

  void spine_bone_pose_set_scale_2(
    spine_bone_pose self,
    double scale,
  ) {
    return _spine_bone_pose_set_scale_2(
      self,
      scale,
    );
  }

  late final _spine_bone_pose_set_scale_2Ptr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_scale_2');
  late final _spine_bone_pose_set_scale_2 = _spine_bone_pose_set_scale_2Ptr
      .asFunction<void Function(spine_bone_pose, double)>();

  double spine_bone_pose_get_shear_x(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_shear_x(
      self,
    );
  }

  late final _spine_bone_pose_get_shear_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_shear_x');
  late final _spine_bone_pose_get_shear_x = _spine_bone_pose_get_shear_xPtr
      .asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_shear_x(
    spine_bone_pose self,
    double shearX,
  ) {
    return _spine_bone_pose_set_shear_x(
      self,
      shearX,
    );
  }

  late final _spine_bone_pose_set_shear_xPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_shear_x');
  late final _spine_bone_pose_set_shear_x = _spine_bone_pose_set_shear_xPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  double spine_bone_pose_get_shear_y(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_shear_y(
      self,
    );
  }

  late final _spine_bone_pose_get_shear_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_pose)>>(
          'spine_bone_pose_get_shear_y');
  late final _spine_bone_pose_get_shear_y = _spine_bone_pose_get_shear_yPtr
      .asFunction<double Function(spine_bone_pose)>();

  void spine_bone_pose_set_shear_y(
    spine_bone_pose self,
    double shearY,
  ) {
    return _spine_bone_pose_set_shear_y(
      self,
      shearY,
    );
  }

  late final _spine_bone_pose_set_shear_yPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Float)>>(
      'spine_bone_pose_set_shear_y');
  late final _spine_bone_pose_set_shear_y = _spine_bone_pose_set_shear_yPtr
      .asFunction<void Function(spine_bone_pose, double)>();

  int spine_bone_pose_get_inherit(
    spine_bone_pose self,
  ) {
    return _spine_bone_pose_get_inherit(
      self,
    );
  }

  late final _spine_bone_pose_get_inheritPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_bone_pose)>>(
          'spine_bone_pose_get_inherit');
  late final _spine_bone_pose_get_inherit = _spine_bone_pose_get_inheritPtr
      .asFunction<int Function(spine_bone_pose)>();

  void spine_bone_pose_set_inherit(
    spine_bone_pose self,
    int inherit,
  ) {
    return _spine_bone_pose_set_inherit(
      self,
      inherit,
    );
  }

  late final _spine_bone_pose_set_inheritPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_pose, ffi.Int32)>>(
      'spine_bone_pose_set_inherit');
  late final _spine_bone_pose_set_inherit = _spine_bone_pose_set_inheritPtr
      .asFunction<void Function(spine_bone_pose, int)>();

  spine_rtti spine_bone_pose_rtti() {
    return _spine_bone_pose_rtti();
  }

  late final _spine_bone_pose_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_bone_pose_rtti');
  late final _spine_bone_pose_rtti =
      _spine_bone_pose_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_bone_timeline_dispose(
    spine_bone_timeline self,
  ) {
    return _spine_bone_timeline_dispose(
      self,
    );
  }

  late final _spine_bone_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline)>>(
          'spine_bone_timeline_dispose');
  late final _spine_bone_timeline_dispose = _spine_bone_timeline_disposePtr
      .asFunction<void Function(spine_bone_timeline)>();

  spine_rtti spine_bone_timeline_get_rtti(
    spine_bone_timeline self,
  ) {
    return _spine_bone_timeline_get_rtti(
      self,
    );
  }

  late final _spine_bone_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_bone_timeline)>>(
          'spine_bone_timeline_get_rtti');
  late final _spine_bone_timeline_get_rtti = _spine_bone_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_bone_timeline)>();

  int spine_bone_timeline_get_bone_index(
    spine_bone_timeline self,
  ) {
    return _spine_bone_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_bone_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_bone_timeline)>>(
          'spine_bone_timeline_get_bone_index');
  late final _spine_bone_timeline_get_bone_index =
      _spine_bone_timeline_get_bone_indexPtr
          .asFunction<int Function(spine_bone_timeline)>();

  void spine_bone_timeline_set_bone_index(
    spine_bone_timeline self,
    int inValue,
  ) {
    return _spine_bone_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_bone_timeline_set_bone_indexPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_timeline, ffi.Int)>>(
      'spine_bone_timeline_set_bone_index');
  late final _spine_bone_timeline_set_bone_index =
      _spine_bone_timeline_set_bone_indexPtr
          .asFunction<void Function(spine_bone_timeline, int)>();

  spine_rtti spine_bone_timeline_rtti() {
    return _spine_bone_timeline_rtti();
  }

  late final _spine_bone_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_bone_timeline_rtti');
  late final _spine_bone_timeline_rtti =
      _spine_bone_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_bone_timeline1_dispose(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_dispose(
      self,
    );
  }

  late final _spine_bone_timeline1_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_dispose');
  late final _spine_bone_timeline1_dispose = _spine_bone_timeline1_disposePtr
      .asFunction<void Function(spine_bone_timeline1)>();

  spine_rtti spine_bone_timeline1_get_rtti(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_rtti(
      self,
    );
  }

  late final _spine_bone_timeline1_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_get_rtti');
  late final _spine_bone_timeline1_get_rtti = _spine_bone_timeline1_get_rttiPtr
      .asFunction<spine_rtti Function(spine_bone_timeline1)>();

  void spine_bone_timeline1_apply(
    spine_bone_timeline1 self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_bone_timeline1_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_bone_timeline1_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_bone_timeline1,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_bone_timeline1_apply');
  late final _spine_bone_timeline1_apply =
      _spine_bone_timeline1_applyPtr.asFunction<
          void Function(spine_bone_timeline1, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_bone_timeline1_set_frame(
    spine_bone_timeline1 self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_bone_timeline1_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_bone_timeline1_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_timeline1, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_bone_timeline1_set_frame');
  late final _spine_bone_timeline1_set_frame =
      _spine_bone_timeline1_set_framePtr.asFunction<
          void Function(spine_bone_timeline1, int, double, double)>();

  double spine_bone_timeline1_get_curve_value(
    spine_bone_timeline1 self,
    double time,
  ) {
    return _spine_bone_timeline1_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_bone_timeline1_get_curve_valuePtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_bone_timeline1, ffi.Float)>>(
      'spine_bone_timeline1_get_curve_value');
  late final _spine_bone_timeline1_get_curve_value =
      _spine_bone_timeline1_get_curve_valuePtr
          .asFunction<double Function(spine_bone_timeline1, double)>();

  double spine_bone_timeline1_get_relative_value(
    spine_bone_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_bone_timeline1_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_bone_timeline1_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_bone_timeline1,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_bone_timeline1_get_relative_value');
  late final _spine_bone_timeline1_get_relative_value =
      _spine_bone_timeline1_get_relative_valuePtr.asFunction<
          double Function(
              spine_bone_timeline1, double, double, int, double, double)>();

  double spine_bone_timeline1_get_absolute_value_1(
    spine_bone_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_bone_timeline1_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_bone_timeline1_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_bone_timeline1,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_bone_timeline1_get_absolute_value_1');
  late final _spine_bone_timeline1_get_absolute_value_1 =
      _spine_bone_timeline1_get_absolute_value_1Ptr.asFunction<
          double Function(
              spine_bone_timeline1, double, double, int, double, double)>();

  double spine_bone_timeline1_get_absolute_value_2(
    spine_bone_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_bone_timeline1_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_bone_timeline1_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_bone_timeline1,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_bone_timeline1_get_absolute_value_2');
  late final _spine_bone_timeline1_get_absolute_value_2 =
      _spine_bone_timeline1_get_absolute_value_2Ptr.asFunction<
          double Function(spine_bone_timeline1, double, double, int, double,
              double, double)>();

  double spine_bone_timeline1_get_scale_value(
    spine_bone_timeline1 self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_bone_timeline1_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_bone_timeline1_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_bone_timeline1,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_bone_timeline1_get_scale_value');
  late final _spine_bone_timeline1_get_scale_value =
      _spine_bone_timeline1_get_scale_valuePtr.asFunction<
          double Function(spine_bone_timeline1, double, double, int, int,
              double, double)>();

  void spine_bone_timeline1_set_linear(
    spine_bone_timeline1 self,
    int frame,
  ) {
    return _spine_bone_timeline1_set_linear(
      self,
      frame,
    );
  }

  late final _spine_bone_timeline1_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_bone_timeline1, ffi.Size)>>(
      'spine_bone_timeline1_set_linear');
  late final _spine_bone_timeline1_set_linear =
      _spine_bone_timeline1_set_linearPtr
          .asFunction<void Function(spine_bone_timeline1, int)>();

  void spine_bone_timeline1_set_stepped(
    spine_bone_timeline1 self,
    int frame,
  ) {
    return _spine_bone_timeline1_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_bone_timeline1_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_bone_timeline1, ffi.Size)>>(
      'spine_bone_timeline1_set_stepped');
  late final _spine_bone_timeline1_set_stepped =
      _spine_bone_timeline1_set_steppedPtr
          .asFunction<void Function(spine_bone_timeline1, int)>();

  void spine_bone_timeline1_set_bezier(
    spine_bone_timeline1 self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_bone_timeline1_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_bone_timeline1_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_bone_timeline1,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_bone_timeline1_set_bezier');
  late final _spine_bone_timeline1_set_bezier =
      _spine_bone_timeline1_set_bezierPtr.asFunction<
          void Function(spine_bone_timeline1, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_bone_timeline1_get_bezier_value(
    spine_bone_timeline1 self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_bone_timeline1_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_bone_timeline1_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_bone_timeline1, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_bone_timeline1_get_bezier_value');
  late final _spine_bone_timeline1_get_bezier_value =
      _spine_bone_timeline1_get_bezier_valuePtr.asFunction<
          double Function(spine_bone_timeline1, double, int, int, int)>();

  spine_array_float spine_bone_timeline1_get_curves(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_curves(
      self,
    );
  }

  late final _spine_bone_timeline1_get_curvesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_bone_timeline1)>>(
      'spine_bone_timeline1_get_curves');
  late final _spine_bone_timeline1_get_curves =
      _spine_bone_timeline1_get_curvesPtr
          .asFunction<spine_array_float Function(spine_bone_timeline1)>();

  int spine_bone_timeline1_get_frame_entries(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_frame_entries(
      self,
    );
  }

  late final _spine_bone_timeline1_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_get_frame_entries');
  late final _spine_bone_timeline1_get_frame_entries =
      _spine_bone_timeline1_get_frame_entriesPtr
          .asFunction<int Function(spine_bone_timeline1)>();

  int spine_bone_timeline1_get_frame_count(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_frame_count(
      self,
    );
  }

  late final _spine_bone_timeline1_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_get_frame_count');
  late final _spine_bone_timeline1_get_frame_count =
      _spine_bone_timeline1_get_frame_countPtr
          .asFunction<int Function(spine_bone_timeline1)>();

  spine_array_float spine_bone_timeline1_get_frames(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_frames(
      self,
    );
  }

  late final _spine_bone_timeline1_get_framesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_bone_timeline1)>>(
      'spine_bone_timeline1_get_frames');
  late final _spine_bone_timeline1_get_frames =
      _spine_bone_timeline1_get_framesPtr
          .asFunction<spine_array_float Function(spine_bone_timeline1)>();

  double spine_bone_timeline1_get_duration(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_duration(
      self,
    );
  }

  late final _spine_bone_timeline1_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_get_duration');
  late final _spine_bone_timeline1_get_duration =
      _spine_bone_timeline1_get_durationPtr
          .asFunction<double Function(spine_bone_timeline1)>();

  spine_array_property_id spine_bone_timeline1_get_property_ids(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_property_ids(
      self,
    );
  }

  late final _spine_bone_timeline1_get_property_idsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_property_id Function(
              spine_bone_timeline1)>>('spine_bone_timeline1_get_property_ids');
  late final _spine_bone_timeline1_get_property_ids =
      _spine_bone_timeline1_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_bone_timeline1)>();

  int spine_bone_timeline1_get_bone_index(
    spine_bone_timeline1 self,
  ) {
    return _spine_bone_timeline1_get_bone_index(
      self,
    );
  }

  late final _spine_bone_timeline1_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_bone_timeline1)>>(
          'spine_bone_timeline1_get_bone_index');
  late final _spine_bone_timeline1_get_bone_index =
      _spine_bone_timeline1_get_bone_indexPtr
          .asFunction<int Function(spine_bone_timeline1)>();

  void spine_bone_timeline1_set_bone_index(
    spine_bone_timeline1 self,
    int inValue,
  ) {
    return _spine_bone_timeline1_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_bone_timeline1_set_bone_indexPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_timeline1, ffi.Int)>>(
      'spine_bone_timeline1_set_bone_index');
  late final _spine_bone_timeline1_set_bone_index =
      _spine_bone_timeline1_set_bone_indexPtr
          .asFunction<void Function(spine_bone_timeline1, int)>();

  spine_rtti spine_bone_timeline1_rtti() {
    return _spine_bone_timeline1_rtti();
  }

  late final _spine_bone_timeline1_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_bone_timeline1_rtti');
  late final _spine_bone_timeline1_rtti =
      _spine_bone_timeline1_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_bone_timeline2_dispose(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_dispose(
      self,
    );
  }

  late final _spine_bone_timeline2_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_timeline2)>>(
          'spine_bone_timeline2_dispose');
  late final _spine_bone_timeline2_dispose = _spine_bone_timeline2_disposePtr
      .asFunction<void Function(spine_bone_timeline2)>();

  spine_rtti spine_bone_timeline2_get_rtti(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_rtti(
      self,
    );
  }

  late final _spine_bone_timeline2_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_bone_timeline2)>>(
          'spine_bone_timeline2_get_rtti');
  late final _spine_bone_timeline2_get_rtti = _spine_bone_timeline2_get_rttiPtr
      .asFunction<spine_rtti Function(spine_bone_timeline2)>();

  void spine_bone_timeline2_apply(
    spine_bone_timeline2 self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_bone_timeline2_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_bone_timeline2_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_bone_timeline2,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_bone_timeline2_apply');
  late final _spine_bone_timeline2_apply =
      _spine_bone_timeline2_applyPtr.asFunction<
          void Function(spine_bone_timeline2, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_bone_timeline2_set_frame(
    spine_bone_timeline2 self,
    int frame,
    double time,
    double value1,
    double value2,
  ) {
    return _spine_bone_timeline2_set_frame(
      self,
      frame,
      time,
      value1,
      value2,
    );
  }

  late final _spine_bone_timeline2_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bone_timeline2, ffi.Size, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_bone_timeline2_set_frame');
  late final _spine_bone_timeline2_set_frame =
      _spine_bone_timeline2_set_framePtr.asFunction<
          void Function(spine_bone_timeline2, int, double, double, double)>();

  double spine_bone_timeline2_get_curve_value(
    spine_bone_timeline2 self,
    double time,
  ) {
    return _spine_bone_timeline2_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_bone_timeline2_get_curve_valuePtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_bone_timeline2, ffi.Float)>>(
      'spine_bone_timeline2_get_curve_value');
  late final _spine_bone_timeline2_get_curve_value =
      _spine_bone_timeline2_get_curve_valuePtr
          .asFunction<double Function(spine_bone_timeline2, double)>();

  void spine_bone_timeline2_set_linear(
    spine_bone_timeline2 self,
    int frame,
  ) {
    return _spine_bone_timeline2_set_linear(
      self,
      frame,
    );
  }

  late final _spine_bone_timeline2_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_bone_timeline2, ffi.Size)>>(
      'spine_bone_timeline2_set_linear');
  late final _spine_bone_timeline2_set_linear =
      _spine_bone_timeline2_set_linearPtr
          .asFunction<void Function(spine_bone_timeline2, int)>();

  void spine_bone_timeline2_set_stepped(
    spine_bone_timeline2 self,
    int frame,
  ) {
    return _spine_bone_timeline2_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_bone_timeline2_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_bone_timeline2, ffi.Size)>>(
      'spine_bone_timeline2_set_stepped');
  late final _spine_bone_timeline2_set_stepped =
      _spine_bone_timeline2_set_steppedPtr
          .asFunction<void Function(spine_bone_timeline2, int)>();

  void spine_bone_timeline2_set_bezier(
    spine_bone_timeline2 self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_bone_timeline2_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_bone_timeline2_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_bone_timeline2,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_bone_timeline2_set_bezier');
  late final _spine_bone_timeline2_set_bezier =
      _spine_bone_timeline2_set_bezierPtr.asFunction<
          void Function(spine_bone_timeline2, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_bone_timeline2_get_bezier_value(
    spine_bone_timeline2 self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_bone_timeline2_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_bone_timeline2_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_bone_timeline2, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_bone_timeline2_get_bezier_value');
  late final _spine_bone_timeline2_get_bezier_value =
      _spine_bone_timeline2_get_bezier_valuePtr.asFunction<
          double Function(spine_bone_timeline2, double, int, int, int)>();

  spine_array_float spine_bone_timeline2_get_curves(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_curves(
      self,
    );
  }

  late final _spine_bone_timeline2_get_curvesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_bone_timeline2)>>(
      'spine_bone_timeline2_get_curves');
  late final _spine_bone_timeline2_get_curves =
      _spine_bone_timeline2_get_curvesPtr
          .asFunction<spine_array_float Function(spine_bone_timeline2)>();

  int spine_bone_timeline2_get_frame_entries(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_frame_entries(
      self,
    );
  }

  late final _spine_bone_timeline2_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_bone_timeline2)>>(
          'spine_bone_timeline2_get_frame_entries');
  late final _spine_bone_timeline2_get_frame_entries =
      _spine_bone_timeline2_get_frame_entriesPtr
          .asFunction<int Function(spine_bone_timeline2)>();

  int spine_bone_timeline2_get_frame_count(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_frame_count(
      self,
    );
  }

  late final _spine_bone_timeline2_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_bone_timeline2)>>(
          'spine_bone_timeline2_get_frame_count');
  late final _spine_bone_timeline2_get_frame_count =
      _spine_bone_timeline2_get_frame_countPtr
          .asFunction<int Function(spine_bone_timeline2)>();

  spine_array_float spine_bone_timeline2_get_frames(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_frames(
      self,
    );
  }

  late final _spine_bone_timeline2_get_framesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_bone_timeline2)>>(
      'spine_bone_timeline2_get_frames');
  late final _spine_bone_timeline2_get_frames =
      _spine_bone_timeline2_get_framesPtr
          .asFunction<spine_array_float Function(spine_bone_timeline2)>();

  double spine_bone_timeline2_get_duration(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_duration(
      self,
    );
  }

  late final _spine_bone_timeline2_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_timeline2)>>(
          'spine_bone_timeline2_get_duration');
  late final _spine_bone_timeline2_get_duration =
      _spine_bone_timeline2_get_durationPtr
          .asFunction<double Function(spine_bone_timeline2)>();

  spine_array_property_id spine_bone_timeline2_get_property_ids(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_property_ids(
      self,
    );
  }

  late final _spine_bone_timeline2_get_property_idsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_property_id Function(
              spine_bone_timeline2)>>('spine_bone_timeline2_get_property_ids');
  late final _spine_bone_timeline2_get_property_ids =
      _spine_bone_timeline2_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_bone_timeline2)>();

  int spine_bone_timeline2_get_bone_index(
    spine_bone_timeline2 self,
  ) {
    return _spine_bone_timeline2_get_bone_index(
      self,
    );
  }

  late final _spine_bone_timeline2_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_bone_timeline2)>>(
          'spine_bone_timeline2_get_bone_index');
  late final _spine_bone_timeline2_get_bone_index =
      _spine_bone_timeline2_get_bone_indexPtr
          .asFunction<int Function(spine_bone_timeline2)>();

  void spine_bone_timeline2_set_bone_index(
    spine_bone_timeline2 self,
    int inValue,
  ) {
    return _spine_bone_timeline2_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_bone_timeline2_set_bone_indexPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bone_timeline2, ffi.Int)>>(
      'spine_bone_timeline2_set_bone_index');
  late final _spine_bone_timeline2_set_bone_index =
      _spine_bone_timeline2_set_bone_indexPtr
          .asFunction<void Function(spine_bone_timeline2, int)>();

  spine_rtti spine_bone_timeline2_rtti() {
    return _spine_bone_timeline2_rtti();
  }

  late final _spine_bone_timeline2_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_bone_timeline2_rtti');
  late final _spine_bone_timeline2_rtti =
      _spine_bone_timeline2_rttiPtr.asFunction<spine_rtti Function()>();

  spine_bounding_box_attachment spine_bounding_box_attachment_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_bounding_box_attachment_create(
      name,
    );
  }

  late final _spine_bounding_box_attachment_createPtr = _lookup<
      ffi.NativeFunction<
          spine_bounding_box_attachment Function(
              ffi.Pointer<ffi.Char>)>>('spine_bounding_box_attachment_create');
  late final _spine_bounding_box_attachment_create =
      _spine_bounding_box_attachment_createPtr.asFunction<
          spine_bounding_box_attachment Function(ffi.Pointer<ffi.Char>)>();

  void spine_bounding_box_attachment_dispose(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_dispose(
      self,
    );
  }

  late final _spine_bounding_box_attachment_disposePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bounding_box_attachment)>>(
      'spine_bounding_box_attachment_dispose');
  late final _spine_bounding_box_attachment_dispose =
      _spine_bounding_box_attachment_disposePtr
          .asFunction<void Function(spine_bounding_box_attachment)>();

  spine_rtti spine_bounding_box_attachment_get_rtti(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_rtti(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_rttiPtr = _lookup<
          ffi
          .NativeFunction<spine_rtti Function(spine_bounding_box_attachment)>>(
      'spine_bounding_box_attachment_get_rtti');
  late final _spine_bounding_box_attachment_get_rtti =
      _spine_bounding_box_attachment_get_rttiPtr
          .asFunction<spine_rtti Function(spine_bounding_box_attachment)>();

  spine_color spine_bounding_box_attachment_get_color(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_color(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_colorPtr = _lookup<
          ffi
          .NativeFunction<spine_color Function(spine_bounding_box_attachment)>>(
      'spine_bounding_box_attachment_get_color');
  late final _spine_bounding_box_attachment_get_color =
      _spine_bounding_box_attachment_get_colorPtr
          .asFunction<spine_color Function(spine_bounding_box_attachment)>();

  spine_attachment spine_bounding_box_attachment_copy(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_copy(
      self,
    );
  }

  late final _spine_bounding_box_attachment_copyPtr = _lookup<
          ffi.NativeFunction<
              spine_attachment Function(spine_bounding_box_attachment)>>(
      'spine_bounding_box_attachment_copy');
  late final _spine_bounding_box_attachment_copy =
      _spine_bounding_box_attachment_copyPtr.asFunction<
          spine_attachment Function(spine_bounding_box_attachment)>();

  void spine_bounding_box_attachment_compute_world_vertices_1(
    spine_bounding_box_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    ffi.Pointer<ffi.Float> worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_bounding_box_attachment_compute_world_vertices_1(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_bounding_box_attachment_compute_world_vertices_1Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_bounding_box_attachment,
                      spine_skeleton,
                      spine_slot,
                      ffi.Size,
                      ffi.Size,
                      ffi.Pointer<ffi.Float>,
                      ffi.Size,
                      ffi.Size)>>(
          'spine_bounding_box_attachment_compute_world_vertices_1');
  late final _spine_bounding_box_attachment_compute_world_vertices_1 =
      _spine_bounding_box_attachment_compute_world_vertices_1Ptr.asFunction<
          void Function(spine_bounding_box_attachment, spine_skeleton,
              spine_slot, int, int, ffi.Pointer<ffi.Float>, int, int)>();

  void spine_bounding_box_attachment_compute_world_vertices_2(
    spine_bounding_box_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    spine_array_float worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_bounding_box_attachment_compute_world_vertices_2(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_bounding_box_attachment_compute_world_vertices_2Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_bounding_box_attachment,
                      spine_skeleton,
                      spine_slot,
                      ffi.Size,
                      ffi.Size,
                      spine_array_float,
                      ffi.Size,
                      ffi.Size)>>(
          'spine_bounding_box_attachment_compute_world_vertices_2');
  late final _spine_bounding_box_attachment_compute_world_vertices_2 =
      _spine_bounding_box_attachment_compute_world_vertices_2Ptr.asFunction<
          void Function(spine_bounding_box_attachment, spine_skeleton,
              spine_slot, int, int, spine_array_float, int, int)>();

  int spine_bounding_box_attachment_get_id(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_id(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_idPtr = _lookup<
          ffi.NativeFunction<ffi.Int Function(spine_bounding_box_attachment)>>(
      'spine_bounding_box_attachment_get_id');
  late final _spine_bounding_box_attachment_get_id =
      _spine_bounding_box_attachment_get_idPtr
          .asFunction<int Function(spine_bounding_box_attachment)>();

  spine_array_int spine_bounding_box_attachment_get_bones(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_bones(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_bonesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_int Function(spine_bounding_box_attachment)>>(
      'spine_bounding_box_attachment_get_bones');
  late final _spine_bounding_box_attachment_get_bones =
      _spine_bounding_box_attachment_get_bonesPtr.asFunction<
          spine_array_int Function(spine_bounding_box_attachment)>();

  void spine_bounding_box_attachment_set_bones(
    spine_bounding_box_attachment self,
    spine_array_int bones,
  ) {
    return _spine_bounding_box_attachment_set_bones(
      self,
      bones,
    );
  }

  late final _spine_bounding_box_attachment_set_bonesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_bounding_box_attachment,
              spine_array_int)>>('spine_bounding_box_attachment_set_bones');
  late final _spine_bounding_box_attachment_set_bones =
      _spine_bounding_box_attachment_set_bonesPtr.asFunction<
          void Function(spine_bounding_box_attachment, spine_array_int)>();

  spine_array_float spine_bounding_box_attachment_get_vertices(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_vertices(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_verticesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_bounding_box_attachment)>>(
      'spine_bounding_box_attachment_get_vertices');
  late final _spine_bounding_box_attachment_get_vertices =
      _spine_bounding_box_attachment_get_verticesPtr.asFunction<
          spine_array_float Function(spine_bounding_box_attachment)>();

  void spine_bounding_box_attachment_set_vertices(
    spine_bounding_box_attachment self,
    spine_array_float vertices,
  ) {
    return _spine_bounding_box_attachment_set_vertices(
      self,
      vertices,
    );
  }

  late final _spine_bounding_box_attachment_set_verticesPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  spine_bounding_box_attachment, spine_array_float)>>(
      'spine_bounding_box_attachment_set_vertices');
  late final _spine_bounding_box_attachment_set_vertices =
      _spine_bounding_box_attachment_set_verticesPtr.asFunction<
          void Function(spine_bounding_box_attachment, spine_array_float)>();

  int spine_bounding_box_attachment_get_world_vertices_length(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_world_vertices_length(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_world_vertices_lengthPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_get_world_vertices_length');
  late final _spine_bounding_box_attachment_get_world_vertices_length =
      _spine_bounding_box_attachment_get_world_vertices_lengthPtr
          .asFunction<int Function(spine_bounding_box_attachment)>();

  void spine_bounding_box_attachment_set_world_vertices_length(
    spine_bounding_box_attachment self,
    int inValue,
  ) {
    return _spine_bounding_box_attachment_set_world_vertices_length(
      self,
      inValue,
    );
  }

  late final _spine_bounding_box_attachment_set_world_vertices_lengthPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(spine_bounding_box_attachment, ffi.Size)>>(
          'spine_bounding_box_attachment_set_world_vertices_length');
  late final _spine_bounding_box_attachment_set_world_vertices_length =
      _spine_bounding_box_attachment_set_world_vertices_lengthPtr
          .asFunction<void Function(spine_bounding_box_attachment, int)>();

  spine_attachment spine_bounding_box_attachment_get_timeline_attachment(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_timeline_attachment(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_timeline_attachmentPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_attachment Function(spine_bounding_box_attachment)>>(
          'spine_bounding_box_attachment_get_timeline_attachment');
  late final _spine_bounding_box_attachment_get_timeline_attachment =
      _spine_bounding_box_attachment_get_timeline_attachmentPtr.asFunction<
          spine_attachment Function(spine_bounding_box_attachment)>();

  void spine_bounding_box_attachment_set_timeline_attachment(
    spine_bounding_box_attachment self,
    spine_attachment attachment,
  ) {
    return _spine_bounding_box_attachment_set_timeline_attachment(
      self,
      attachment,
    );
  }

  late final _spine_bounding_box_attachment_set_timeline_attachmentPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_bounding_box_attachment, spine_attachment)>>(
          'spine_bounding_box_attachment_set_timeline_attachment');
  late final _spine_bounding_box_attachment_set_timeline_attachment =
      _spine_bounding_box_attachment_set_timeline_attachmentPtr.asFunction<
          void Function(spine_bounding_box_attachment, spine_attachment)>();

  void spine_bounding_box_attachment_copy_to(
    spine_bounding_box_attachment self,
    spine_vertex_attachment other,
  ) {
    return _spine_bounding_box_attachment_copy_to(
      self,
      other,
    );
  }

  late final _spine_bounding_box_attachment_copy_toPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  spine_bounding_box_attachment, spine_vertex_attachment)>>(
      'spine_bounding_box_attachment_copy_to');
  late final _spine_bounding_box_attachment_copy_to =
      _spine_bounding_box_attachment_copy_toPtr.asFunction<
          void Function(
              spine_bounding_box_attachment, spine_vertex_attachment)>();

  ffi.Pointer<ffi.Char> spine_bounding_box_attachment_get_name(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_name(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_namePtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(spine_bounding_box_attachment)>>(
      'spine_bounding_box_attachment_get_name');
  late final _spine_bounding_box_attachment_get_name =
      _spine_bounding_box_attachment_get_namePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(spine_bounding_box_attachment)>();

  int spine_bounding_box_attachment_get_ref_count(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_bounding_box_attachment_get_ref_countPtr = _lookup<
          ffi.NativeFunction<ffi.Int Function(spine_bounding_box_attachment)>>(
      'spine_bounding_box_attachment_get_ref_count');
  late final _spine_bounding_box_attachment_get_ref_count =
      _spine_bounding_box_attachment_get_ref_countPtr
          .asFunction<int Function(spine_bounding_box_attachment)>();

  void spine_bounding_box_attachment_reference(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_reference(
      self,
    );
  }

  late final _spine_bounding_box_attachment_referencePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bounding_box_attachment)>>(
      'spine_bounding_box_attachment_reference');
  late final _spine_bounding_box_attachment_reference =
      _spine_bounding_box_attachment_referencePtr
          .asFunction<void Function(spine_bounding_box_attachment)>();

  void spine_bounding_box_attachment_dereference(
    spine_bounding_box_attachment self,
  ) {
    return _spine_bounding_box_attachment_dereference(
      self,
    );
  }

  late final _spine_bounding_box_attachment_dereferencePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_bounding_box_attachment)>>(
      'spine_bounding_box_attachment_dereference');
  late final _spine_bounding_box_attachment_dereference =
      _spine_bounding_box_attachment_dereferencePtr
          .asFunction<void Function(spine_bounding_box_attachment)>();

  spine_rtti spine_bounding_box_attachment_rtti() {
    return _spine_bounding_box_attachment_rtti();
  }

  late final _spine_bounding_box_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_bounding_box_attachment_rtti');
  late final _spine_bounding_box_attachment_rtti =
      _spine_bounding_box_attachment_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_clipping_attachment spine_clipping_attachment_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_clipping_attachment_create(
      name,
    );
  }

  late final _spine_clipping_attachment_createPtr = _lookup<
      ffi.NativeFunction<
          spine_clipping_attachment Function(
              ffi.Pointer<ffi.Char>)>>('spine_clipping_attachment_create');
  late final _spine_clipping_attachment_create =
      _spine_clipping_attachment_createPtr.asFunction<
          spine_clipping_attachment Function(ffi.Pointer<ffi.Char>)>();

  void spine_clipping_attachment_dispose(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_dispose(
      self,
    );
  }

  late final _spine_clipping_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_dispose');
  late final _spine_clipping_attachment_dispose =
      _spine_clipping_attachment_disposePtr
          .asFunction<void Function(spine_clipping_attachment)>();

  spine_rtti spine_clipping_attachment_get_rtti(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_rtti(
      self,
    );
  }

  late final _spine_clipping_attachment_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_clipping_attachment)>>(
      'spine_clipping_attachment_get_rtti');
  late final _spine_clipping_attachment_get_rtti =
      _spine_clipping_attachment_get_rttiPtr
          .asFunction<spine_rtti Function(spine_clipping_attachment)>();

  spine_slot_data spine_clipping_attachment_get_end_slot(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_end_slot(
      self,
    );
  }

  late final _spine_clipping_attachment_get_end_slotPtr = _lookup<
          ffi
          .NativeFunction<spine_slot_data Function(spine_clipping_attachment)>>(
      'spine_clipping_attachment_get_end_slot');
  late final _spine_clipping_attachment_get_end_slot =
      _spine_clipping_attachment_get_end_slotPtr
          .asFunction<spine_slot_data Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_set_end_slot(
    spine_clipping_attachment self,
    spine_slot_data inValue,
  ) {
    return _spine_clipping_attachment_set_end_slot(
      self,
      inValue,
    );
  }

  late final _spine_clipping_attachment_set_end_slotPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_clipping_attachment,
              spine_slot_data)>>('spine_clipping_attachment_set_end_slot');
  late final _spine_clipping_attachment_set_end_slot =
      _spine_clipping_attachment_set_end_slotPtr.asFunction<
          void Function(spine_clipping_attachment, spine_slot_data)>();

  spine_color spine_clipping_attachment_get_color(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_color(
      self,
    );
  }

  late final _spine_clipping_attachment_get_colorPtr = _lookup<
          ffi.NativeFunction<spine_color Function(spine_clipping_attachment)>>(
      'spine_clipping_attachment_get_color');
  late final _spine_clipping_attachment_get_color =
      _spine_clipping_attachment_get_colorPtr
          .asFunction<spine_color Function(spine_clipping_attachment)>();

  spine_attachment spine_clipping_attachment_copy(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_copy(
      self,
    );
  }

  late final _spine_clipping_attachment_copyPtr = _lookup<
      ffi.NativeFunction<
          spine_attachment Function(
              spine_clipping_attachment)>>('spine_clipping_attachment_copy');
  late final _spine_clipping_attachment_copy =
      _spine_clipping_attachment_copyPtr
          .asFunction<spine_attachment Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_compute_world_vertices_1(
    spine_clipping_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    ffi.Pointer<ffi.Float> worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_clipping_attachment_compute_world_vertices_1(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_clipping_attachment_compute_world_vertices_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_clipping_attachment,
              spine_skeleton,
              spine_slot,
              ffi.Size,
              ffi.Size,
              ffi.Pointer<ffi.Float>,
              ffi.Size,
              ffi.Size)>>('spine_clipping_attachment_compute_world_vertices_1');
  late final _spine_clipping_attachment_compute_world_vertices_1 =
      _spine_clipping_attachment_compute_world_vertices_1Ptr.asFunction<
          void Function(spine_clipping_attachment, spine_skeleton, spine_slot,
              int, int, ffi.Pointer<ffi.Float>, int, int)>();

  void spine_clipping_attachment_compute_world_vertices_2(
    spine_clipping_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    spine_array_float worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_clipping_attachment_compute_world_vertices_2(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_clipping_attachment_compute_world_vertices_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_clipping_attachment,
              spine_skeleton,
              spine_slot,
              ffi.Size,
              ffi.Size,
              spine_array_float,
              ffi.Size,
              ffi.Size)>>('spine_clipping_attachment_compute_world_vertices_2');
  late final _spine_clipping_attachment_compute_world_vertices_2 =
      _spine_clipping_attachment_compute_world_vertices_2Ptr.asFunction<
          void Function(spine_clipping_attachment, spine_skeleton, spine_slot,
              int, int, spine_array_float, int, int)>();

  int spine_clipping_attachment_get_id(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_id(
      self,
    );
  }

  late final _spine_clipping_attachment_get_idPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_get_id');
  late final _spine_clipping_attachment_get_id =
      _spine_clipping_attachment_get_idPtr
          .asFunction<int Function(spine_clipping_attachment)>();

  spine_array_int spine_clipping_attachment_get_bones(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_bones(
      self,
    );
  }

  late final _spine_clipping_attachment_get_bonesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_int Function(spine_clipping_attachment)>>(
      'spine_clipping_attachment_get_bones');
  late final _spine_clipping_attachment_get_bones =
      _spine_clipping_attachment_get_bonesPtr
          .asFunction<spine_array_int Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_set_bones(
    spine_clipping_attachment self,
    spine_array_int bones,
  ) {
    return _spine_clipping_attachment_set_bones(
      self,
      bones,
    );
  }

  late final _spine_clipping_attachment_set_bonesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_clipping_attachment,
              spine_array_int)>>('spine_clipping_attachment_set_bones');
  late final _spine_clipping_attachment_set_bones =
      _spine_clipping_attachment_set_bonesPtr.asFunction<
          void Function(spine_clipping_attachment, spine_array_int)>();

  spine_array_float spine_clipping_attachment_get_vertices(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_vertices(
      self,
    );
  }

  late final _spine_clipping_attachment_get_verticesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_clipping_attachment)>>(
      'spine_clipping_attachment_get_vertices');
  late final _spine_clipping_attachment_get_vertices =
      _spine_clipping_attachment_get_verticesPtr
          .asFunction<spine_array_float Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_set_vertices(
    spine_clipping_attachment self,
    spine_array_float vertices,
  ) {
    return _spine_clipping_attachment_set_vertices(
      self,
      vertices,
    );
  }

  late final _spine_clipping_attachment_set_verticesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_clipping_attachment,
              spine_array_float)>>('spine_clipping_attachment_set_vertices');
  late final _spine_clipping_attachment_set_vertices =
      _spine_clipping_attachment_set_verticesPtr.asFunction<
          void Function(spine_clipping_attachment, spine_array_float)>();

  int spine_clipping_attachment_get_world_vertices_length(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_world_vertices_length(
      self,
    );
  }

  late final _spine_clipping_attachment_get_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_get_world_vertices_length');
  late final _spine_clipping_attachment_get_world_vertices_length =
      _spine_clipping_attachment_get_world_vertices_lengthPtr
          .asFunction<int Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_set_world_vertices_length(
    spine_clipping_attachment self,
    int inValue,
  ) {
    return _spine_clipping_attachment_set_world_vertices_length(
      self,
      inValue,
    );
  }

  late final _spine_clipping_attachment_set_world_vertices_lengthPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_clipping_attachment, ffi.Size)>>(
      'spine_clipping_attachment_set_world_vertices_length');
  late final _spine_clipping_attachment_set_world_vertices_length =
      _spine_clipping_attachment_set_world_vertices_lengthPtr
          .asFunction<void Function(spine_clipping_attachment, int)>();

  spine_attachment spine_clipping_attachment_get_timeline_attachment(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_timeline_attachment(
      self,
    );
  }

  late final _spine_clipping_attachment_get_timeline_attachmentPtr = _lookup<
          ffi.NativeFunction<
              spine_attachment Function(spine_clipping_attachment)>>(
      'spine_clipping_attachment_get_timeline_attachment');
  late final _spine_clipping_attachment_get_timeline_attachment =
      _spine_clipping_attachment_get_timeline_attachmentPtr
          .asFunction<spine_attachment Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_set_timeline_attachment(
    spine_clipping_attachment self,
    spine_attachment attachment,
  ) {
    return _spine_clipping_attachment_set_timeline_attachment(
      self,
      attachment,
    );
  }

  late final _spine_clipping_attachment_set_timeline_attachmentPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_clipping_attachment, spine_attachment)>>(
      'spine_clipping_attachment_set_timeline_attachment');
  late final _spine_clipping_attachment_set_timeline_attachment =
      _spine_clipping_attachment_set_timeline_attachmentPtr.asFunction<
          void Function(spine_clipping_attachment, spine_attachment)>();

  void spine_clipping_attachment_copy_to(
    spine_clipping_attachment self,
    spine_vertex_attachment other,
  ) {
    return _spine_clipping_attachment_copy_to(
      self,
      other,
    );
  }

  late final _spine_clipping_attachment_copy_toPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_clipping_attachment,
              spine_vertex_attachment)>>('spine_clipping_attachment_copy_to');
  late final _spine_clipping_attachment_copy_to =
      _spine_clipping_attachment_copy_toPtr.asFunction<
          void Function(spine_clipping_attachment, spine_vertex_attachment)>();

  ffi.Pointer<ffi.Char> spine_clipping_attachment_get_name(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_name(
      self,
    );
  }

  late final _spine_clipping_attachment_get_namePtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(spine_clipping_attachment)>>(
      'spine_clipping_attachment_get_name');
  late final _spine_clipping_attachment_get_name =
      _spine_clipping_attachment_get_namePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(spine_clipping_attachment)>();

  int spine_clipping_attachment_get_ref_count(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_clipping_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_get_ref_count');
  late final _spine_clipping_attachment_get_ref_count =
      _spine_clipping_attachment_get_ref_countPtr
          .asFunction<int Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_reference(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_reference(
      self,
    );
  }

  late final _spine_clipping_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_reference');
  late final _spine_clipping_attachment_reference =
      _spine_clipping_attachment_referencePtr
          .asFunction<void Function(spine_clipping_attachment)>();

  void spine_clipping_attachment_dereference(
    spine_clipping_attachment self,
  ) {
    return _spine_clipping_attachment_dereference(
      self,
    );
  }

  late final _spine_clipping_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment)>>(
          'spine_clipping_attachment_dereference');
  late final _spine_clipping_attachment_dereference =
      _spine_clipping_attachment_dereferencePtr
          .asFunction<void Function(spine_clipping_attachment)>();

  spine_rtti spine_clipping_attachment_rtti() {
    return _spine_clipping_attachment_rtti();
  }

  late final _spine_clipping_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_clipping_attachment_rtti');
  late final _spine_clipping_attachment_rtti =
      _spine_clipping_attachment_rttiPtr.asFunction<spine_rtti Function()>();

  spine_color spine_color_create() {
    return _spine_color_create();
  }

  late final _spine_color_createPtr =
      _lookup<ffi.NativeFunction<spine_color Function()>>('spine_color_create');
  late final _spine_color_create =
      _spine_color_createPtr.asFunction<spine_color Function()>();

  spine_color spine_color_create2(
    double r,
    double g,
    double b,
    double a,
  ) {
    return _spine_color_create2(
      r,
      g,
      b,
      a,
    );
  }

  late final _spine_color_create2Ptr = _lookup<
      ffi.NativeFunction<
          spine_color Function(ffi.Float, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_color_create2');
  late final _spine_color_create2 = _spine_color_create2Ptr
      .asFunction<spine_color Function(double, double, double, double)>();

  void spine_color_dispose(
    spine_color self,
  ) {
    return _spine_color_dispose(
      self,
    );
  }

  late final _spine_color_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color)>>(
          'spine_color_dispose');
  late final _spine_color_dispose =
      _spine_color_disposePtr.asFunction<void Function(spine_color)>();

  spine_color spine_color_set_1(
    spine_color self,
    double _r,
    double _g,
    double _b,
    double _a,
  ) {
    return _spine_color_set_1(
      self,
      _r,
      _g,
      _b,
      _a,
    );
  }

  late final _spine_color_set_1Ptr = _lookup<
      ffi.NativeFunction<
          spine_color Function(spine_color, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_color_set_1');
  late final _spine_color_set_1 = _spine_color_set_1Ptr.asFunction<
      spine_color Function(spine_color, double, double, double, double)>();

  spine_color spine_color_set_2(
    spine_color self,
    double _r,
    double _g,
    double _b,
  ) {
    return _spine_color_set_2(
      self,
      _r,
      _g,
      _b,
    );
  }

  late final _spine_color_set_2Ptr = _lookup<
      ffi.NativeFunction<
          spine_color Function(spine_color, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_color_set_2');
  late final _spine_color_set_2 = _spine_color_set_2Ptr
      .asFunction<spine_color Function(spine_color, double, double, double)>();

  spine_color spine_color_set_3(
    spine_color self,
    spine_color other,
  ) {
    return _spine_color_set_3(
      self,
      other,
    );
  }

  late final _spine_color_set_3Ptr = _lookup<
          ffi.NativeFunction<spine_color Function(spine_color, spine_color)>>(
      'spine_color_set_3');
  late final _spine_color_set_3 = _spine_color_set_3Ptr
      .asFunction<spine_color Function(spine_color, spine_color)>();

  spine_color spine_color_add_1(
    spine_color self,
    double _r,
    double _g,
    double _b,
    double _a,
  ) {
    return _spine_color_add_1(
      self,
      _r,
      _g,
      _b,
      _a,
    );
  }

  late final _spine_color_add_1Ptr = _lookup<
      ffi.NativeFunction<
          spine_color Function(spine_color, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_color_add_1');
  late final _spine_color_add_1 = _spine_color_add_1Ptr.asFunction<
      spine_color Function(spine_color, double, double, double, double)>();

  spine_color spine_color_add_2(
    spine_color self,
    double _r,
    double _g,
    double _b,
  ) {
    return _spine_color_add_2(
      self,
      _r,
      _g,
      _b,
    );
  }

  late final _spine_color_add_2Ptr = _lookup<
      ffi.NativeFunction<
          spine_color Function(spine_color, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_color_add_2');
  late final _spine_color_add_2 = _spine_color_add_2Ptr
      .asFunction<spine_color Function(spine_color, double, double, double)>();

  spine_color spine_color_add_3(
    spine_color self,
    spine_color other,
  ) {
    return _spine_color_add_3(
      self,
      other,
    );
  }

  late final _spine_color_add_3Ptr = _lookup<
          ffi.NativeFunction<spine_color Function(spine_color, spine_color)>>(
      'spine_color_add_3');
  late final _spine_color_add_3 = _spine_color_add_3Ptr
      .asFunction<spine_color Function(spine_color, spine_color)>();

  spine_color spine_color_clamp(
    spine_color self,
  ) {
    return _spine_color_clamp(
      self,
    );
  }

  late final _spine_color_clampPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_color)>>(
          'spine_color_clamp');
  late final _spine_color_clamp =
      _spine_color_clampPtr.asFunction<spine_color Function(spine_color)>();

  double spine_color_parse_hex(
    ffi.Pointer<ffi.Char> value,
    int index,
  ) {
    return _spine_color_parse_hex(
      value,
      index,
    );
  }

  late final _spine_color_parse_hexPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(ffi.Pointer<ffi.Char>, ffi.Size)>>(
      'spine_color_parse_hex');
  late final _spine_color_parse_hex = _spine_color_parse_hexPtr
      .asFunction<double Function(ffi.Pointer<ffi.Char>, int)>();

  void spine_color_rgba8888_to_color(
    spine_color color,
    int value,
  ) {
    return _spine_color_rgba8888_to_color(
      color,
      value,
    );
  }

  late final _spine_color_rgba8888_to_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color, ffi.Int)>>(
          'spine_color_rgba8888_to_color');
  late final _spine_color_rgba8888_to_color = _spine_color_rgba8888_to_colorPtr
      .asFunction<void Function(spine_color, int)>();

  void spine_color_rgb888_to_color(
    spine_color color,
    int value,
  ) {
    return _spine_color_rgb888_to_color(
      color,
      value,
    );
  }

  late final _spine_color_rgb888_to_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color, ffi.Int)>>(
          'spine_color_rgb888_to_color');
  late final _spine_color_rgb888_to_color = _spine_color_rgb888_to_colorPtr
      .asFunction<void Function(spine_color, int)>();

  double spine_color_get_r(
    spine_color self,
  ) {
    return _spine_color_get_r(
      self,
    );
  }

  late final _spine_color_get_rPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_color)>>(
          'spine_color_get_r');
  late final _spine_color_get_r =
      _spine_color_get_rPtr.asFunction<double Function(spine_color)>();

  void spine_color_set_r(
    spine_color self,
    double value,
  ) {
    return _spine_color_set_r(
      self,
      value,
    );
  }

  late final _spine_color_set_rPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color, ffi.Float)>>(
          'spine_color_set_r');
  late final _spine_color_set_r =
      _spine_color_set_rPtr.asFunction<void Function(spine_color, double)>();

  double spine_color_get_g(
    spine_color self,
  ) {
    return _spine_color_get_g(
      self,
    );
  }

  late final _spine_color_get_gPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_color)>>(
          'spine_color_get_g');
  late final _spine_color_get_g =
      _spine_color_get_gPtr.asFunction<double Function(spine_color)>();

  void spine_color_set_g(
    spine_color self,
    double value,
  ) {
    return _spine_color_set_g(
      self,
      value,
    );
  }

  late final _spine_color_set_gPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color, ffi.Float)>>(
          'spine_color_set_g');
  late final _spine_color_set_g =
      _spine_color_set_gPtr.asFunction<void Function(spine_color, double)>();

  double spine_color_get_b(
    spine_color self,
  ) {
    return _spine_color_get_b(
      self,
    );
  }

  late final _spine_color_get_bPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_color)>>(
          'spine_color_get_b');
  late final _spine_color_get_b =
      _spine_color_get_bPtr.asFunction<double Function(spine_color)>();

  void spine_color_set_b(
    spine_color self,
    double value,
  ) {
    return _spine_color_set_b(
      self,
      value,
    );
  }

  late final _spine_color_set_bPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color, ffi.Float)>>(
          'spine_color_set_b');
  late final _spine_color_set_b =
      _spine_color_set_bPtr.asFunction<void Function(spine_color, double)>();

  double spine_color_get_a(
    spine_color self,
  ) {
    return _spine_color_get_a(
      self,
    );
  }

  late final _spine_color_get_aPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_color)>>(
          'spine_color_get_a');
  late final _spine_color_get_a =
      _spine_color_get_aPtr.asFunction<double Function(spine_color)>();

  void spine_color_set_a(
    spine_color self,
    double value,
  ) {
    return _spine_color_set_a(
      self,
      value,
    );
  }

  late final _spine_color_set_aPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_color, ffi.Float)>>(
          'spine_color_set_a');
  late final _spine_color_set_a =
      _spine_color_set_aPtr.asFunction<void Function(spine_color, double)>();

  void spine_constraint_dispose(
    spine_constraint self,
  ) {
    return _spine_constraint_dispose(
      self,
    );
  }

  late final _spine_constraint_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint)>>(
          'spine_constraint_dispose');
  late final _spine_constraint_dispose = _spine_constraint_disposePtr
      .asFunction<void Function(spine_constraint)>();

  spine_rtti spine_constraint_get_rtti(
    spine_constraint self,
  ) {
    return _spine_constraint_get_rtti(
      self,
    );
  }

  late final _spine_constraint_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_constraint)>>(
          'spine_constraint_get_rtti');
  late final _spine_constraint_get_rtti = _spine_constraint_get_rttiPtr
      .asFunction<spine_rtti Function(spine_constraint)>();

  spine_constraint_data spine_constraint_get_data(
    spine_constraint self,
  ) {
    return _spine_constraint_get_data(
      self,
    );
  }

  late final _spine_constraint_get_dataPtr = _lookup<
          ffi.NativeFunction<spine_constraint_data Function(spine_constraint)>>(
      'spine_constraint_get_data');
  late final _spine_constraint_get_data = _spine_constraint_get_dataPtr
      .asFunction<spine_constraint_data Function(spine_constraint)>();

  void spine_constraint_sort(
    spine_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_constraint_sort(
      self,
      skeleton,
    );
  }

  late final _spine_constraint_sortPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_constraint, spine_skeleton)>>(
      'spine_constraint_sort');
  late final _spine_constraint_sort = _spine_constraint_sortPtr
      .asFunction<void Function(spine_constraint, spine_skeleton)>();

  bool spine_constraint_is_source_active(
    spine_constraint self,
  ) {
    return _spine_constraint_is_source_active(
      self,
    );
  }

  late final _spine_constraint_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_constraint)>>(
          'spine_constraint_is_source_active');
  late final _spine_constraint_is_source_active =
      _spine_constraint_is_source_activePtr
          .asFunction<bool Function(spine_constraint)>();

  void spine_constraint_update(
    spine_constraint self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_constraint_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_constraint_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_constraint, spine_skeleton,
              ffi.Int32)>>('spine_constraint_update');
  late final _spine_constraint_update = _spine_constraint_updatePtr
      .asFunction<void Function(spine_constraint, spine_skeleton, int)>();

  spine_rtti spine_constraint_rtti() {
    return _spine_constraint_rtti();
  }

  late final _spine_constraint_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_constraint_rtti');
  late final _spine_constraint_rtti =
      _spine_constraint_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_constraint_data_dispose(
    spine_constraint_data self,
  ) {
    return _spine_constraint_data_dispose(
      self,
    );
  }

  late final _spine_constraint_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_data)>>(
          'spine_constraint_data_dispose');
  late final _spine_constraint_data_dispose = _spine_constraint_data_disposePtr
      .asFunction<void Function(spine_constraint_data)>();

  spine_rtti spine_constraint_data_get_rtti(
    spine_constraint_data self,
  ) {
    return _spine_constraint_data_get_rtti(
      self,
    );
  }

  late final _spine_constraint_data_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_constraint_data)>>(
          'spine_constraint_data_get_rtti');
  late final _spine_constraint_data_get_rtti =
      _spine_constraint_data_get_rttiPtr
          .asFunction<spine_rtti Function(spine_constraint_data)>();

  spine_constraint spine_constraint_data_create_method(
    spine_constraint_data self,
    spine_skeleton skeleton,
  ) {
    return _spine_constraint_data_create_method(
      self,
      skeleton,
    );
  }

  late final _spine_constraint_data_create_methodPtr = _lookup<
      ffi.NativeFunction<
          spine_constraint Function(spine_constraint_data,
              spine_skeleton)>>('spine_constraint_data_create_method');
  late final _spine_constraint_data_create_method =
      _spine_constraint_data_create_methodPtr.asFunction<
          spine_constraint Function(spine_constraint_data, spine_skeleton)>();

  ffi.Pointer<ffi.Char> spine_constraint_data_get_name(
    spine_constraint_data self,
  ) {
    return _spine_constraint_data_get_name(
      self,
    );
  }

  late final _spine_constraint_data_get_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              spine_constraint_data)>>('spine_constraint_data_get_name');
  late final _spine_constraint_data_get_name =
      _spine_constraint_data_get_namePtr
          .asFunction<ffi.Pointer<ffi.Char> Function(spine_constraint_data)>();

  bool spine_constraint_data_get_skin_required(
    spine_constraint_data self,
  ) {
    return _spine_constraint_data_get_skin_required(
      self,
    );
  }

  late final _spine_constraint_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_constraint_data)>>(
          'spine_constraint_data_get_skin_required');
  late final _spine_constraint_data_get_skin_required =
      _spine_constraint_data_get_skin_requiredPtr
          .asFunction<bool Function(spine_constraint_data)>();

  spine_rtti spine_constraint_data_rtti() {
    return _spine_constraint_data_rtti();
  }

  late final _spine_constraint_data_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_constraint_data_rtti');
  late final _spine_constraint_data_rtti =
      _spine_constraint_data_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_constraint_timeline_dispose(
    spine_constraint_timeline self,
  ) {
    return _spine_constraint_timeline_dispose(
      self,
    );
  }

  late final _spine_constraint_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_dispose');
  late final _spine_constraint_timeline_dispose =
      _spine_constraint_timeline_disposePtr
          .asFunction<void Function(spine_constraint_timeline)>();

  spine_rtti spine_constraint_timeline_get_rtti(
    spine_constraint_timeline self,
  ) {
    return _spine_constraint_timeline_get_rtti(
      self,
    );
  }

  late final _spine_constraint_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_constraint_timeline)>>(
      'spine_constraint_timeline_get_rtti');
  late final _spine_constraint_timeline_get_rtti =
      _spine_constraint_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_constraint_timeline)>();

  int spine_constraint_timeline_get_constraint_index(
    spine_constraint_timeline self,
  ) {
    return _spine_constraint_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_constraint_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_constraint_timeline)>>(
          'spine_constraint_timeline_get_constraint_index');
  late final _spine_constraint_timeline_get_constraint_index =
      _spine_constraint_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_constraint_timeline)>();

  void spine_constraint_timeline_set_constraint_index(
    spine_constraint_timeline self,
    int inValue,
  ) {
    return _spine_constraint_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_constraint_timeline_set_constraint_indexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_constraint_timeline,
              ffi.Int)>>('spine_constraint_timeline_set_constraint_index');
  late final _spine_constraint_timeline_set_constraint_index =
      _spine_constraint_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_constraint_timeline, int)>();

  spine_rtti spine_constraint_timeline_rtti() {
    return _spine_constraint_timeline_rtti();
  }

  late final _spine_constraint_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_constraint_timeline_rtti');
  late final _spine_constraint_timeline_rtti =
      _spine_constraint_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_constraint_timeline1_dispose(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_dispose(
      self,
    );
  }

  late final _spine_constraint_timeline1_disposePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_constraint_timeline1)>>(
      'spine_constraint_timeline1_dispose');
  late final _spine_constraint_timeline1_dispose =
      _spine_constraint_timeline1_disposePtr
          .asFunction<void Function(spine_constraint_timeline1)>();

  spine_rtti spine_constraint_timeline1_get_rtti(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_rtti(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_constraint_timeline1)>>(
      'spine_constraint_timeline1_get_rtti');
  late final _spine_constraint_timeline1_get_rtti =
      _spine_constraint_timeline1_get_rttiPtr
          .asFunction<spine_rtti Function(spine_constraint_timeline1)>();

  void spine_constraint_timeline1_set_frame(
    spine_constraint_timeline1 self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_constraint_timeline1_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_constraint_timeline1_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_constraint_timeline1, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_constraint_timeline1_set_frame');
  late final _spine_constraint_timeline1_set_frame =
      _spine_constraint_timeline1_set_framePtr.asFunction<
          void Function(spine_constraint_timeline1, int, double, double)>();

  double spine_constraint_timeline1_get_curve_value(
    spine_constraint_timeline1 self,
    double time,
  ) {
    return _spine_constraint_timeline1_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_constraint_timeline1_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_constraint_timeline1,
              ffi.Float)>>('spine_constraint_timeline1_get_curve_value');
  late final _spine_constraint_timeline1_get_curve_value =
      _spine_constraint_timeline1_get_curve_valuePtr
          .asFunction<double Function(spine_constraint_timeline1, double)>();

  double spine_constraint_timeline1_get_relative_value(
    spine_constraint_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_constraint_timeline1_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_constraint_timeline1_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_constraint_timeline1,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_constraint_timeline1_get_relative_value');
  late final _spine_constraint_timeline1_get_relative_value =
      _spine_constraint_timeline1_get_relative_valuePtr.asFunction<
          double Function(spine_constraint_timeline1, double, double, int,
              double, double)>();

  double spine_constraint_timeline1_get_absolute_value_1(
    spine_constraint_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_constraint_timeline1_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_constraint_timeline1_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_constraint_timeline1,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_constraint_timeline1_get_absolute_value_1');
  late final _spine_constraint_timeline1_get_absolute_value_1 =
      _spine_constraint_timeline1_get_absolute_value_1Ptr.asFunction<
          double Function(spine_constraint_timeline1, double, double, int,
              double, double)>();

  double spine_constraint_timeline1_get_absolute_value_2(
    spine_constraint_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_constraint_timeline1_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_constraint_timeline1_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_constraint_timeline1,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_constraint_timeline1_get_absolute_value_2');
  late final _spine_constraint_timeline1_get_absolute_value_2 =
      _spine_constraint_timeline1_get_absolute_value_2Ptr.asFunction<
          double Function(spine_constraint_timeline1, double, double, int,
              double, double, double)>();

  double spine_constraint_timeline1_get_scale_value(
    spine_constraint_timeline1 self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_constraint_timeline1_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_constraint_timeline1_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_constraint_timeline1,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_constraint_timeline1_get_scale_value');
  late final _spine_constraint_timeline1_get_scale_value =
      _spine_constraint_timeline1_get_scale_valuePtr.asFunction<
          double Function(spine_constraint_timeline1, double, double, int, int,
              double, double)>();

  void spine_constraint_timeline1_set_linear(
    spine_constraint_timeline1 self,
    int frame,
  ) {
    return _spine_constraint_timeline1_set_linear(
      self,
      frame,
    );
  }

  late final _spine_constraint_timeline1_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_constraint_timeline1,
              ffi.Size)>>('spine_constraint_timeline1_set_linear');
  late final _spine_constraint_timeline1_set_linear =
      _spine_constraint_timeline1_set_linearPtr
          .asFunction<void Function(spine_constraint_timeline1, int)>();

  void spine_constraint_timeline1_set_stepped(
    spine_constraint_timeline1 self,
    int frame,
  ) {
    return _spine_constraint_timeline1_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_constraint_timeline1_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_constraint_timeline1,
              ffi.Size)>>('spine_constraint_timeline1_set_stepped');
  late final _spine_constraint_timeline1_set_stepped =
      _spine_constraint_timeline1_set_steppedPtr
          .asFunction<void Function(spine_constraint_timeline1, int)>();

  void spine_constraint_timeline1_set_bezier(
    spine_constraint_timeline1 self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_constraint_timeline1_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_constraint_timeline1_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_constraint_timeline1,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_constraint_timeline1_set_bezier');
  late final _spine_constraint_timeline1_set_bezier =
      _spine_constraint_timeline1_set_bezierPtr.asFunction<
          void Function(spine_constraint_timeline1, int, int, double, double,
              double, double, double, double, double, double, double)>();

  double spine_constraint_timeline1_get_bezier_value(
    spine_constraint_timeline1 self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_constraint_timeline1_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_constraint_timeline1_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_constraint_timeline1,
              ffi.Float,
              ffi.Size,
              ffi.Size,
              ffi.Size)>>('spine_constraint_timeline1_get_bezier_value');
  late final _spine_constraint_timeline1_get_bezier_value =
      _spine_constraint_timeline1_get_bezier_valuePtr.asFunction<
          double Function(spine_constraint_timeline1, double, int, int, int)>();

  spine_array_float spine_constraint_timeline1_get_curves(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_curves(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_constraint_timeline1)>>(
      'spine_constraint_timeline1_get_curves');
  late final _spine_constraint_timeline1_get_curves =
      _spine_constraint_timeline1_get_curvesPtr
          .asFunction<spine_array_float Function(spine_constraint_timeline1)>();

  void spine_constraint_timeline1_apply(
    spine_constraint_timeline1 self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_constraint_timeline1_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_constraint_timeline1_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_constraint_timeline1,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_constraint_timeline1_apply');
  late final _spine_constraint_timeline1_apply =
      _spine_constraint_timeline1_applyPtr.asFunction<
          void Function(spine_constraint_timeline1, spine_skeleton, double,
              double, spine_array_event, double, int, int, bool)>();

  int spine_constraint_timeline1_get_frame_entries(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_frame_entries(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_frame_entriesPtr = _lookup<
          ffi.NativeFunction<ffi.Size Function(spine_constraint_timeline1)>>(
      'spine_constraint_timeline1_get_frame_entries');
  late final _spine_constraint_timeline1_get_frame_entries =
      _spine_constraint_timeline1_get_frame_entriesPtr
          .asFunction<int Function(spine_constraint_timeline1)>();

  int spine_constraint_timeline1_get_frame_count(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_frame_count(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_frame_countPtr = _lookup<
          ffi.NativeFunction<ffi.Size Function(spine_constraint_timeline1)>>(
      'spine_constraint_timeline1_get_frame_count');
  late final _spine_constraint_timeline1_get_frame_count =
      _spine_constraint_timeline1_get_frame_countPtr
          .asFunction<int Function(spine_constraint_timeline1)>();

  spine_array_float spine_constraint_timeline1_get_frames(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_frames(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_constraint_timeline1)>>(
      'spine_constraint_timeline1_get_frames');
  late final _spine_constraint_timeline1_get_frames =
      _spine_constraint_timeline1_get_framesPtr
          .asFunction<spine_array_float Function(spine_constraint_timeline1)>();

  double spine_constraint_timeline1_get_duration(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_duration(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_durationPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_constraint_timeline1)>>(
      'spine_constraint_timeline1_get_duration');
  late final _spine_constraint_timeline1_get_duration =
      _spine_constraint_timeline1_get_durationPtr
          .asFunction<double Function(spine_constraint_timeline1)>();

  spine_array_property_id spine_constraint_timeline1_get_property_ids(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_property_ids(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_constraint_timeline1)>>(
      'spine_constraint_timeline1_get_property_ids');
  late final _spine_constraint_timeline1_get_property_ids =
      _spine_constraint_timeline1_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_constraint_timeline1)>();

  int spine_constraint_timeline1_get_constraint_index(
    spine_constraint_timeline1 self,
  ) {
    return _spine_constraint_timeline1_get_constraint_index(
      self,
    );
  }

  late final _spine_constraint_timeline1_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_constraint_timeline1)>>(
          'spine_constraint_timeline1_get_constraint_index');
  late final _spine_constraint_timeline1_get_constraint_index =
      _spine_constraint_timeline1_get_constraint_indexPtr
          .asFunction<int Function(spine_constraint_timeline1)>();

  void spine_constraint_timeline1_set_constraint_index(
    spine_constraint_timeline1 self,
    int inValue,
  ) {
    return _spine_constraint_timeline1_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_constraint_timeline1_set_constraint_indexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_constraint_timeline1,
              ffi.Int)>>('spine_constraint_timeline1_set_constraint_index');
  late final _spine_constraint_timeline1_set_constraint_index =
      _spine_constraint_timeline1_set_constraint_indexPtr
          .asFunction<void Function(spine_constraint_timeline1, int)>();

  spine_rtti spine_constraint_timeline1_rtti() {
    return _spine_constraint_timeline1_rtti();
  }

  late final _spine_constraint_timeline1_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_constraint_timeline1_rtti');
  late final _spine_constraint_timeline1_rtti =
      _spine_constraint_timeline1_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_curve_timeline_dispose(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_dispose(
      self,
    );
  }

  late final _spine_curve_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_curve_timeline)>>(
          'spine_curve_timeline_dispose');
  late final _spine_curve_timeline_dispose = _spine_curve_timeline_disposePtr
      .asFunction<void Function(spine_curve_timeline)>();

  spine_rtti spine_curve_timeline_get_rtti(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_rtti(
      self,
    );
  }

  late final _spine_curve_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_curve_timeline)>>(
          'spine_curve_timeline_get_rtti');
  late final _spine_curve_timeline_get_rtti = _spine_curve_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_curve_timeline)>();

  void spine_curve_timeline_set_linear(
    spine_curve_timeline self,
    int frame,
  ) {
    return _spine_curve_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_curve_timeline_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_curve_timeline, ffi.Size)>>(
      'spine_curve_timeline_set_linear');
  late final _spine_curve_timeline_set_linear =
      _spine_curve_timeline_set_linearPtr
          .asFunction<void Function(spine_curve_timeline, int)>();

  void spine_curve_timeline_set_stepped(
    spine_curve_timeline self,
    int frame,
  ) {
    return _spine_curve_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_curve_timeline_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_curve_timeline, ffi.Size)>>(
      'spine_curve_timeline_set_stepped');
  late final _spine_curve_timeline_set_stepped =
      _spine_curve_timeline_set_steppedPtr
          .asFunction<void Function(spine_curve_timeline, int)>();

  void spine_curve_timeline_set_bezier(
    spine_curve_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_curve_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_curve_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_curve_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_curve_timeline_set_bezier');
  late final _spine_curve_timeline_set_bezier =
      _spine_curve_timeline_set_bezierPtr.asFunction<
          void Function(spine_curve_timeline, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_curve_timeline_get_bezier_value(
    spine_curve_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_curve_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_curve_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_curve_timeline, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_curve_timeline_get_bezier_value');
  late final _spine_curve_timeline_get_bezier_value =
      _spine_curve_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_curve_timeline, double, int, int, int)>();

  spine_array_float spine_curve_timeline_get_curves(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_curves(
      self,
    );
  }

  late final _spine_curve_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_curve_timeline)>>(
      'spine_curve_timeline_get_curves');
  late final _spine_curve_timeline_get_curves =
      _spine_curve_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_curve_timeline)>();

  void spine_curve_timeline_apply(
    spine_curve_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_curve_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_curve_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_curve_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_curve_timeline_apply');
  late final _spine_curve_timeline_apply =
      _spine_curve_timeline_applyPtr.asFunction<
          void Function(spine_curve_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  int spine_curve_timeline_get_frame_entries(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_curve_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_curve_timeline)>>(
          'spine_curve_timeline_get_frame_entries');
  late final _spine_curve_timeline_get_frame_entries =
      _spine_curve_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_curve_timeline)>();

  int spine_curve_timeline_get_frame_count(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_curve_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_curve_timeline)>>(
          'spine_curve_timeline_get_frame_count');
  late final _spine_curve_timeline_get_frame_count =
      _spine_curve_timeline_get_frame_countPtr
          .asFunction<int Function(spine_curve_timeline)>();

  spine_array_float spine_curve_timeline_get_frames(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_frames(
      self,
    );
  }

  late final _spine_curve_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_curve_timeline)>>(
      'spine_curve_timeline_get_frames');
  late final _spine_curve_timeline_get_frames =
      _spine_curve_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_curve_timeline)>();

  double spine_curve_timeline_get_duration(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_duration(
      self,
    );
  }

  late final _spine_curve_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_curve_timeline)>>(
          'spine_curve_timeline_get_duration');
  late final _spine_curve_timeline_get_duration =
      _spine_curve_timeline_get_durationPtr
          .asFunction<double Function(spine_curve_timeline)>();

  spine_array_property_id spine_curve_timeline_get_property_ids(
    spine_curve_timeline self,
  ) {
    return _spine_curve_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_curve_timeline_get_property_idsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_property_id Function(
              spine_curve_timeline)>>('spine_curve_timeline_get_property_ids');
  late final _spine_curve_timeline_get_property_ids =
      _spine_curve_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_curve_timeline)>();

  spine_rtti spine_curve_timeline_rtti() {
    return _spine_curve_timeline_rtti();
  }

  late final _spine_curve_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_curve_timeline_rtti');
  late final _spine_curve_timeline_rtti =
      _spine_curve_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_curve_timeline1_dispose(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_dispose(
      self,
    );
  }

  late final _spine_curve_timeline1_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_dispose');
  late final _spine_curve_timeline1_dispose = _spine_curve_timeline1_disposePtr
      .asFunction<void Function(spine_curve_timeline1)>();

  spine_rtti spine_curve_timeline1_get_rtti(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_rtti(
      self,
    );
  }

  late final _spine_curve_timeline1_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_get_rtti');
  late final _spine_curve_timeline1_get_rtti =
      _spine_curve_timeline1_get_rttiPtr
          .asFunction<spine_rtti Function(spine_curve_timeline1)>();

  void spine_curve_timeline1_set_frame(
    spine_curve_timeline1 self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_curve_timeline1_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_curve_timeline1_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_curve_timeline1, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_curve_timeline1_set_frame');
  late final _spine_curve_timeline1_set_frame =
      _spine_curve_timeline1_set_framePtr.asFunction<
          void Function(spine_curve_timeline1, int, double, double)>();

  double spine_curve_timeline1_get_curve_value(
    spine_curve_timeline1 self,
    double time,
  ) {
    return _spine_curve_timeline1_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_curve_timeline1_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_curve_timeline1,
              ffi.Float)>>('spine_curve_timeline1_get_curve_value');
  late final _spine_curve_timeline1_get_curve_value =
      _spine_curve_timeline1_get_curve_valuePtr
          .asFunction<double Function(spine_curve_timeline1, double)>();

  double spine_curve_timeline1_get_relative_value(
    spine_curve_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_curve_timeline1_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_curve_timeline1_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_curve_timeline1,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_curve_timeline1_get_relative_value');
  late final _spine_curve_timeline1_get_relative_value =
      _spine_curve_timeline1_get_relative_valuePtr.asFunction<
          double Function(
              spine_curve_timeline1, double, double, int, double, double)>();

  double spine_curve_timeline1_get_absolute_value_1(
    spine_curve_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_curve_timeline1_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_curve_timeline1_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_curve_timeline1,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_curve_timeline1_get_absolute_value_1');
  late final _spine_curve_timeline1_get_absolute_value_1 =
      _spine_curve_timeline1_get_absolute_value_1Ptr.asFunction<
          double Function(
              spine_curve_timeline1, double, double, int, double, double)>();

  double spine_curve_timeline1_get_absolute_value_2(
    spine_curve_timeline1 self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_curve_timeline1_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_curve_timeline1_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_curve_timeline1,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_curve_timeline1_get_absolute_value_2');
  late final _spine_curve_timeline1_get_absolute_value_2 =
      _spine_curve_timeline1_get_absolute_value_2Ptr.asFunction<
          double Function(spine_curve_timeline1, double, double, int, double,
              double, double)>();

  double spine_curve_timeline1_get_scale_value(
    spine_curve_timeline1 self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_curve_timeline1_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_curve_timeline1_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_curve_timeline1,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_curve_timeline1_get_scale_value');
  late final _spine_curve_timeline1_get_scale_value =
      _spine_curve_timeline1_get_scale_valuePtr.asFunction<
          double Function(spine_curve_timeline1, double, double, int, int,
              double, double)>();

  void spine_curve_timeline1_set_linear(
    spine_curve_timeline1 self,
    int frame,
  ) {
    return _spine_curve_timeline1_set_linear(
      self,
      frame,
    );
  }

  late final _spine_curve_timeline1_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_curve_timeline1, ffi.Size)>>(
      'spine_curve_timeline1_set_linear');
  late final _spine_curve_timeline1_set_linear =
      _spine_curve_timeline1_set_linearPtr
          .asFunction<void Function(spine_curve_timeline1, int)>();

  void spine_curve_timeline1_set_stepped(
    spine_curve_timeline1 self,
    int frame,
  ) {
    return _spine_curve_timeline1_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_curve_timeline1_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_curve_timeline1, ffi.Size)>>(
      'spine_curve_timeline1_set_stepped');
  late final _spine_curve_timeline1_set_stepped =
      _spine_curve_timeline1_set_steppedPtr
          .asFunction<void Function(spine_curve_timeline1, int)>();

  void spine_curve_timeline1_set_bezier(
    spine_curve_timeline1 self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_curve_timeline1_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_curve_timeline1_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_curve_timeline1,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_curve_timeline1_set_bezier');
  late final _spine_curve_timeline1_set_bezier =
      _spine_curve_timeline1_set_bezierPtr.asFunction<
          void Function(spine_curve_timeline1, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_curve_timeline1_get_bezier_value(
    spine_curve_timeline1 self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_curve_timeline1_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_curve_timeline1_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_curve_timeline1, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_curve_timeline1_get_bezier_value');
  late final _spine_curve_timeline1_get_bezier_value =
      _spine_curve_timeline1_get_bezier_valuePtr.asFunction<
          double Function(spine_curve_timeline1, double, int, int, int)>();

  spine_array_float spine_curve_timeline1_get_curves(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_curves(
      self,
    );
  }

  late final _spine_curve_timeline1_get_curvesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_curve_timeline1)>>(
      'spine_curve_timeline1_get_curves');
  late final _spine_curve_timeline1_get_curves =
      _spine_curve_timeline1_get_curvesPtr
          .asFunction<spine_array_float Function(spine_curve_timeline1)>();

  void spine_curve_timeline1_apply(
    spine_curve_timeline1 self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_curve_timeline1_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_curve_timeline1_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_curve_timeline1,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_curve_timeline1_apply');
  late final _spine_curve_timeline1_apply =
      _spine_curve_timeline1_applyPtr.asFunction<
          void Function(spine_curve_timeline1, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  int spine_curve_timeline1_get_frame_entries(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_frame_entries(
      self,
    );
  }

  late final _spine_curve_timeline1_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_get_frame_entries');
  late final _spine_curve_timeline1_get_frame_entries =
      _spine_curve_timeline1_get_frame_entriesPtr
          .asFunction<int Function(spine_curve_timeline1)>();

  int spine_curve_timeline1_get_frame_count(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_frame_count(
      self,
    );
  }

  late final _spine_curve_timeline1_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_get_frame_count');
  late final _spine_curve_timeline1_get_frame_count =
      _spine_curve_timeline1_get_frame_countPtr
          .asFunction<int Function(spine_curve_timeline1)>();

  spine_array_float spine_curve_timeline1_get_frames(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_frames(
      self,
    );
  }

  late final _spine_curve_timeline1_get_framesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_curve_timeline1)>>(
      'spine_curve_timeline1_get_frames');
  late final _spine_curve_timeline1_get_frames =
      _spine_curve_timeline1_get_framesPtr
          .asFunction<spine_array_float Function(spine_curve_timeline1)>();

  double spine_curve_timeline1_get_duration(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_duration(
      self,
    );
  }

  late final _spine_curve_timeline1_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_curve_timeline1)>>(
          'spine_curve_timeline1_get_duration');
  late final _spine_curve_timeline1_get_duration =
      _spine_curve_timeline1_get_durationPtr
          .asFunction<double Function(spine_curve_timeline1)>();

  spine_array_property_id spine_curve_timeline1_get_property_ids(
    spine_curve_timeline1 self,
  ) {
    return _spine_curve_timeline1_get_property_ids(
      self,
    );
  }

  late final _spine_curve_timeline1_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_curve_timeline1)>>(
      'spine_curve_timeline1_get_property_ids');
  late final _spine_curve_timeline1_get_property_ids =
      _spine_curve_timeline1_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_curve_timeline1)>();

  spine_rtti spine_curve_timeline1_rtti() {
    return _spine_curve_timeline1_rtti();
  }

  late final _spine_curve_timeline1_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_curve_timeline1_rtti');
  late final _spine_curve_timeline1_rtti =
      _spine_curve_timeline1_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_curve_timeline2_dispose(
    spine_curve_timeline2 self,
  ) {
    return _spine_curve_timeline2_dispose(
      self,
    );
  }

  late final _spine_curve_timeline2_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_curve_timeline2)>>(
          'spine_curve_timeline2_dispose');
  late final _spine_curve_timeline2_dispose = _spine_curve_timeline2_disposePtr
      .asFunction<void Function(spine_curve_timeline2)>();

  spine_rtti spine_curve_timeline2_get_rtti(
    spine_curve_timeline2 self,
  ) {
    return _spine_curve_timeline2_get_rtti(
      self,
    );
  }

  late final _spine_curve_timeline2_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_curve_timeline2)>>(
          'spine_curve_timeline2_get_rtti');
  late final _spine_curve_timeline2_get_rtti =
      _spine_curve_timeline2_get_rttiPtr
          .asFunction<spine_rtti Function(spine_curve_timeline2)>();

  void spine_curve_timeline2_set_frame(
    spine_curve_timeline2 self,
    int frame,
    double time,
    double value1,
    double value2,
  ) {
    return _spine_curve_timeline2_set_frame(
      self,
      frame,
      time,
      value1,
      value2,
    );
  }

  late final _spine_curve_timeline2_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_curve_timeline2, ffi.Size, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_curve_timeline2_set_frame');
  late final _spine_curve_timeline2_set_frame =
      _spine_curve_timeline2_set_framePtr.asFunction<
          void Function(spine_curve_timeline2, int, double, double, double)>();

  double spine_curve_timeline2_get_curve_value(
    spine_curve_timeline2 self,
    double time,
  ) {
    return _spine_curve_timeline2_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_curve_timeline2_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_curve_timeline2,
              ffi.Float)>>('spine_curve_timeline2_get_curve_value');
  late final _spine_curve_timeline2_get_curve_value =
      _spine_curve_timeline2_get_curve_valuePtr
          .asFunction<double Function(spine_curve_timeline2, double)>();

  void spine_curve_timeline2_set_linear(
    spine_curve_timeline2 self,
    int frame,
  ) {
    return _spine_curve_timeline2_set_linear(
      self,
      frame,
    );
  }

  late final _spine_curve_timeline2_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_curve_timeline2, ffi.Size)>>(
      'spine_curve_timeline2_set_linear');
  late final _spine_curve_timeline2_set_linear =
      _spine_curve_timeline2_set_linearPtr
          .asFunction<void Function(spine_curve_timeline2, int)>();

  void spine_curve_timeline2_set_stepped(
    spine_curve_timeline2 self,
    int frame,
  ) {
    return _spine_curve_timeline2_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_curve_timeline2_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_curve_timeline2, ffi.Size)>>(
      'spine_curve_timeline2_set_stepped');
  late final _spine_curve_timeline2_set_stepped =
      _spine_curve_timeline2_set_steppedPtr
          .asFunction<void Function(spine_curve_timeline2, int)>();

  void spine_curve_timeline2_set_bezier(
    spine_curve_timeline2 self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_curve_timeline2_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_curve_timeline2_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_curve_timeline2,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_curve_timeline2_set_bezier');
  late final _spine_curve_timeline2_set_bezier =
      _spine_curve_timeline2_set_bezierPtr.asFunction<
          void Function(spine_curve_timeline2, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_curve_timeline2_get_bezier_value(
    spine_curve_timeline2 self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_curve_timeline2_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_curve_timeline2_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_curve_timeline2, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_curve_timeline2_get_bezier_value');
  late final _spine_curve_timeline2_get_bezier_value =
      _spine_curve_timeline2_get_bezier_valuePtr.asFunction<
          double Function(spine_curve_timeline2, double, int, int, int)>();

  spine_array_float spine_curve_timeline2_get_curves(
    spine_curve_timeline2 self,
  ) {
    return _spine_curve_timeline2_get_curves(
      self,
    );
  }

  late final _spine_curve_timeline2_get_curvesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_curve_timeline2)>>(
      'spine_curve_timeline2_get_curves');
  late final _spine_curve_timeline2_get_curves =
      _spine_curve_timeline2_get_curvesPtr
          .asFunction<spine_array_float Function(spine_curve_timeline2)>();

  void spine_curve_timeline2_apply(
    spine_curve_timeline2 self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_curve_timeline2_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_curve_timeline2_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_curve_timeline2,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_curve_timeline2_apply');
  late final _spine_curve_timeline2_apply =
      _spine_curve_timeline2_applyPtr.asFunction<
          void Function(spine_curve_timeline2, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  int spine_curve_timeline2_get_frame_entries(
    spine_curve_timeline2 self,
  ) {
    return _spine_curve_timeline2_get_frame_entries(
      self,
    );
  }

  late final _spine_curve_timeline2_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_curve_timeline2)>>(
          'spine_curve_timeline2_get_frame_entries');
  late final _spine_curve_timeline2_get_frame_entries =
      _spine_curve_timeline2_get_frame_entriesPtr
          .asFunction<int Function(spine_curve_timeline2)>();

  int spine_curve_timeline2_get_frame_count(
    spine_curve_timeline2 self,
  ) {
    return _spine_curve_timeline2_get_frame_count(
      self,
    );
  }

  late final _spine_curve_timeline2_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_curve_timeline2)>>(
          'spine_curve_timeline2_get_frame_count');
  late final _spine_curve_timeline2_get_frame_count =
      _spine_curve_timeline2_get_frame_countPtr
          .asFunction<int Function(spine_curve_timeline2)>();

  spine_array_float spine_curve_timeline2_get_frames(
    spine_curve_timeline2 self,
  ) {
    return _spine_curve_timeline2_get_frames(
      self,
    );
  }

  late final _spine_curve_timeline2_get_framesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_curve_timeline2)>>(
      'spine_curve_timeline2_get_frames');
  late final _spine_curve_timeline2_get_frames =
      _spine_curve_timeline2_get_framesPtr
          .asFunction<spine_array_float Function(spine_curve_timeline2)>();

  double spine_curve_timeline2_get_duration(
    spine_curve_timeline2 self,
  ) {
    return _spine_curve_timeline2_get_duration(
      self,
    );
  }

  late final _spine_curve_timeline2_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_curve_timeline2)>>(
          'spine_curve_timeline2_get_duration');
  late final _spine_curve_timeline2_get_duration =
      _spine_curve_timeline2_get_durationPtr
          .asFunction<double Function(spine_curve_timeline2)>();

  spine_array_property_id spine_curve_timeline2_get_property_ids(
    spine_curve_timeline2 self,
  ) {
    return _spine_curve_timeline2_get_property_ids(
      self,
    );
  }

  late final _spine_curve_timeline2_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_curve_timeline2)>>(
      'spine_curve_timeline2_get_property_ids');
  late final _spine_curve_timeline2_get_property_ids =
      _spine_curve_timeline2_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_curve_timeline2)>();

  spine_rtti spine_curve_timeline2_rtti() {
    return _spine_curve_timeline2_rtti();
  }

  late final _spine_curve_timeline2_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_curve_timeline2_rtti');
  late final _spine_curve_timeline2_rtti =
      _spine_curve_timeline2_rttiPtr.asFunction<spine_rtti Function()>();

  spine_deform_timeline spine_deform_timeline_create(
    int frameCount,
    int bezierCount,
    int slotIndex,
    spine_vertex_attachment attachment,
  ) {
    return _spine_deform_timeline_create(
      frameCount,
      bezierCount,
      slotIndex,
      attachment,
    );
  }

  late final _spine_deform_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_deform_timeline Function(ffi.Size, ffi.Size, ffi.Int,
              spine_vertex_attachment)>>('spine_deform_timeline_create');
  late final _spine_deform_timeline_create =
      _spine_deform_timeline_createPtr.asFunction<
          spine_deform_timeline Function(
              int, int, int, spine_vertex_attachment)>();

  void spine_deform_timeline_dispose(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_dispose(
      self,
    );
  }

  late final _spine_deform_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_deform_timeline)>>(
          'spine_deform_timeline_dispose');
  late final _spine_deform_timeline_dispose = _spine_deform_timeline_disposePtr
      .asFunction<void Function(spine_deform_timeline)>();

  spine_rtti spine_deform_timeline_get_rtti(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_rtti(
      self,
    );
  }

  late final _spine_deform_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_deform_timeline)>>(
          'spine_deform_timeline_get_rtti');
  late final _spine_deform_timeline_get_rtti =
      _spine_deform_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_deform_timeline)>();

  void spine_deform_timeline_set_frame(
    spine_deform_timeline self,
    int frameIndex,
    double time,
    spine_array_float vertices,
  ) {
    return _spine_deform_timeline_set_frame(
      self,
      frameIndex,
      time,
      vertices,
    );
  }

  late final _spine_deform_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_deform_timeline, ffi.Int, ffi.Float,
              spine_array_float)>>('spine_deform_timeline_set_frame');
  late final _spine_deform_timeline_set_frame =
      _spine_deform_timeline_set_framePtr.asFunction<
          void Function(
              spine_deform_timeline, int, double, spine_array_float)>();

  spine_vertex_attachment spine_deform_timeline_get_attachment(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_attachment(
      self,
    );
  }

  late final _spine_deform_timeline_get_attachmentPtr = _lookup<
      ffi.NativeFunction<
          spine_vertex_attachment Function(
              spine_deform_timeline)>>('spine_deform_timeline_get_attachment');
  late final _spine_deform_timeline_get_attachment =
      _spine_deform_timeline_get_attachmentPtr.asFunction<
          spine_vertex_attachment Function(spine_deform_timeline)>();

  void spine_deform_timeline_set_attachment(
    spine_deform_timeline self,
    spine_vertex_attachment inValue,
  ) {
    return _spine_deform_timeline_set_attachment(
      self,
      inValue,
    );
  }

  late final _spine_deform_timeline_set_attachmentPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  spine_deform_timeline, spine_vertex_attachment)>>(
      'spine_deform_timeline_set_attachment');
  late final _spine_deform_timeline_set_attachment =
      _spine_deform_timeline_set_attachmentPtr.asFunction<
          void Function(spine_deform_timeline, spine_vertex_attachment)>();

  void spine_deform_timeline_set_bezier(
    spine_deform_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_deform_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_deform_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_deform_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_deform_timeline_set_bezier');
  late final _spine_deform_timeline_set_bezier =
      _spine_deform_timeline_set_bezierPtr.asFunction<
          void Function(spine_deform_timeline, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_deform_timeline_get_curve_percent(
    spine_deform_timeline self,
    double time,
    int frame,
  ) {
    return _spine_deform_timeline_get_curve_percent(
      self,
      time,
      frame,
    );
  }

  late final _spine_deform_timeline_get_curve_percentPtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_deform_timeline, ffi.Float,
              ffi.Int)>>('spine_deform_timeline_get_curve_percent');
  late final _spine_deform_timeline_get_curve_percent =
      _spine_deform_timeline_get_curve_percentPtr
          .asFunction<double Function(spine_deform_timeline, double, int)>();

  int spine_deform_timeline_get_frame_count(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_deform_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_deform_timeline)>>(
          'spine_deform_timeline_get_frame_count');
  late final _spine_deform_timeline_get_frame_count =
      _spine_deform_timeline_get_frame_countPtr
          .asFunction<int Function(spine_deform_timeline)>();

  void spine_deform_timeline_apply(
    spine_deform_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_deform_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_deform_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_deform_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_deform_timeline_apply');
  late final _spine_deform_timeline_apply =
      _spine_deform_timeline_applyPtr.asFunction<
          void Function(spine_deform_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_deform_timeline_set_linear(
    spine_deform_timeline self,
    int frame,
  ) {
    return _spine_deform_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_deform_timeline_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_deform_timeline, ffi.Size)>>(
      'spine_deform_timeline_set_linear');
  late final _spine_deform_timeline_set_linear =
      _spine_deform_timeline_set_linearPtr
          .asFunction<void Function(spine_deform_timeline, int)>();

  void spine_deform_timeline_set_stepped(
    spine_deform_timeline self,
    int frame,
  ) {
    return _spine_deform_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_deform_timeline_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_deform_timeline, ffi.Size)>>(
      'spine_deform_timeline_set_stepped');
  late final _spine_deform_timeline_set_stepped =
      _spine_deform_timeline_set_steppedPtr
          .asFunction<void Function(spine_deform_timeline, int)>();

  double spine_deform_timeline_get_bezier_value(
    spine_deform_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_deform_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_deform_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_deform_timeline, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_deform_timeline_get_bezier_value');
  late final _spine_deform_timeline_get_bezier_value =
      _spine_deform_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_deform_timeline, double, int, int, int)>();

  spine_array_float spine_deform_timeline_get_curves(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_curves(
      self,
    );
  }

  late final _spine_deform_timeline_get_curvesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_deform_timeline)>>(
      'spine_deform_timeline_get_curves');
  late final _spine_deform_timeline_get_curves =
      _spine_deform_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_deform_timeline)>();

  int spine_deform_timeline_get_frame_entries(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_deform_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_deform_timeline)>>(
          'spine_deform_timeline_get_frame_entries');
  late final _spine_deform_timeline_get_frame_entries =
      _spine_deform_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_deform_timeline)>();

  spine_array_float spine_deform_timeline_get_frames(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_frames(
      self,
    );
  }

  late final _spine_deform_timeline_get_framesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_deform_timeline)>>(
      'spine_deform_timeline_get_frames');
  late final _spine_deform_timeline_get_frames =
      _spine_deform_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_deform_timeline)>();

  double spine_deform_timeline_get_duration(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_duration(
      self,
    );
  }

  late final _spine_deform_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_deform_timeline)>>(
          'spine_deform_timeline_get_duration');
  late final _spine_deform_timeline_get_duration =
      _spine_deform_timeline_get_durationPtr
          .asFunction<double Function(spine_deform_timeline)>();

  spine_array_property_id spine_deform_timeline_get_property_ids(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_deform_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_deform_timeline)>>(
      'spine_deform_timeline_get_property_ids');
  late final _spine_deform_timeline_get_property_ids =
      _spine_deform_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_deform_timeline)>();

  int spine_deform_timeline_get_slot_index(
    spine_deform_timeline self,
  ) {
    return _spine_deform_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_deform_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_deform_timeline)>>(
          'spine_deform_timeline_get_slot_index');
  late final _spine_deform_timeline_get_slot_index =
      _spine_deform_timeline_get_slot_indexPtr
          .asFunction<int Function(spine_deform_timeline)>();

  void spine_deform_timeline_set_slot_index(
    spine_deform_timeline self,
    int inValue,
  ) {
    return _spine_deform_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_deform_timeline_set_slot_indexPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_deform_timeline, ffi.Int)>>(
      'spine_deform_timeline_set_slot_index');
  late final _spine_deform_timeline_set_slot_index =
      _spine_deform_timeline_set_slot_indexPtr
          .asFunction<void Function(spine_deform_timeline, int)>();

  spine_rtti spine_deform_timeline_rtti() {
    return _spine_deform_timeline_rtti();
  }

  late final _spine_deform_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_deform_timeline_rtti');
  late final _spine_deform_timeline_rtti =
      _spine_deform_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_draw_order_timeline spine_draw_order_timeline_create(
    int frameCount,
  ) {
    return _spine_draw_order_timeline_create(
      frameCount,
    );
  }

  late final _spine_draw_order_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_draw_order_timeline Function(ffi.Size)>>(
          'spine_draw_order_timeline_create');
  late final _spine_draw_order_timeline_create =
      _spine_draw_order_timeline_createPtr
          .asFunction<spine_draw_order_timeline Function(int)>();

  void spine_draw_order_timeline_dispose(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_dispose(
      self,
    );
  }

  late final _spine_draw_order_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_draw_order_timeline)>>(
          'spine_draw_order_timeline_dispose');
  late final _spine_draw_order_timeline_dispose =
      _spine_draw_order_timeline_disposePtr
          .asFunction<void Function(spine_draw_order_timeline)>();

  spine_rtti spine_draw_order_timeline_get_rtti(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_get_rtti(
      self,
    );
  }

  late final _spine_draw_order_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_draw_order_timeline)>>(
      'spine_draw_order_timeline_get_rtti');
  late final _spine_draw_order_timeline_get_rtti =
      _spine_draw_order_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_draw_order_timeline)>();

  void spine_draw_order_timeline_apply(
    spine_draw_order_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_draw_order_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_draw_order_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_draw_order_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_draw_order_timeline_apply');
  late final _spine_draw_order_timeline_apply =
      _spine_draw_order_timeline_applyPtr.asFunction<
          void Function(spine_draw_order_timeline, spine_skeleton, double,
              double, spine_array_event, double, int, int, bool)>();

  int spine_draw_order_timeline_get_frame_count(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_draw_order_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_draw_order_timeline)>>(
          'spine_draw_order_timeline_get_frame_count');
  late final _spine_draw_order_timeline_get_frame_count =
      _spine_draw_order_timeline_get_frame_countPtr
          .asFunction<int Function(spine_draw_order_timeline)>();

  void spine_draw_order_timeline_set_frame(
    spine_draw_order_timeline self,
    int frame,
    double time,
    spine_array_int drawOrder,
  ) {
    return _spine_draw_order_timeline_set_frame(
      self,
      frame,
      time,
      drawOrder,
    );
  }

  late final _spine_draw_order_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_draw_order_timeline, ffi.Size, ffi.Float,
              spine_array_int)>>('spine_draw_order_timeline_set_frame');
  late final _spine_draw_order_timeline_set_frame =
      _spine_draw_order_timeline_set_framePtr.asFunction<
          void Function(
              spine_draw_order_timeline, int, double, spine_array_int)>();

  int spine_draw_order_timeline_get_frame_entries(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_draw_order_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_draw_order_timeline)>>(
          'spine_draw_order_timeline_get_frame_entries');
  late final _spine_draw_order_timeline_get_frame_entries =
      _spine_draw_order_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_draw_order_timeline)>();

  spine_array_float spine_draw_order_timeline_get_frames(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_get_frames(
      self,
    );
  }

  late final _spine_draw_order_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_draw_order_timeline)>>(
      'spine_draw_order_timeline_get_frames');
  late final _spine_draw_order_timeline_get_frames =
      _spine_draw_order_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_draw_order_timeline)>();

  double spine_draw_order_timeline_get_duration(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_get_duration(
      self,
    );
  }

  late final _spine_draw_order_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_draw_order_timeline)>>(
      'spine_draw_order_timeline_get_duration');
  late final _spine_draw_order_timeline_get_duration =
      _spine_draw_order_timeline_get_durationPtr
          .asFunction<double Function(spine_draw_order_timeline)>();

  spine_array_property_id spine_draw_order_timeline_get_property_ids(
    spine_draw_order_timeline self,
  ) {
    return _spine_draw_order_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_draw_order_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_draw_order_timeline)>>(
      'spine_draw_order_timeline_get_property_ids');
  late final _spine_draw_order_timeline_get_property_ids =
      _spine_draw_order_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_draw_order_timeline)>();

  spine_rtti spine_draw_order_timeline_rtti() {
    return _spine_draw_order_timeline_rtti();
  }

  late final _spine_draw_order_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_draw_order_timeline_rtti');
  late final _spine_draw_order_timeline_rtti =
      _spine_draw_order_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_event spine_event_create(
    double time,
    spine_event_data data,
  ) {
    return _spine_event_create(
      time,
      data,
    );
  }

  late final _spine_event_createPtr = _lookup<
          ffi
          .NativeFunction<spine_event Function(ffi.Float, spine_event_data)>>(
      'spine_event_create');
  late final _spine_event_create = _spine_event_createPtr
      .asFunction<spine_event Function(double, spine_event_data)>();

  void spine_event_dispose(
    spine_event self,
  ) {
    return _spine_event_dispose(
      self,
    );
  }

  late final _spine_event_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event)>>(
          'spine_event_dispose');
  late final _spine_event_dispose =
      _spine_event_disposePtr.asFunction<void Function(spine_event)>();

  spine_event_data spine_event_get_data(
    spine_event self,
  ) {
    return _spine_event_get_data(
      self,
    );
  }

  late final _spine_event_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_event_data Function(spine_event)>>(
          'spine_event_get_data');
  late final _spine_event_get_data = _spine_event_get_dataPtr
      .asFunction<spine_event_data Function(spine_event)>();

  double spine_event_get_time(
    spine_event self,
  ) {
    return _spine_event_get_time(
      self,
    );
  }

  late final _spine_event_get_timePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
          'spine_event_get_time');
  late final _spine_event_get_time =
      _spine_event_get_timePtr.asFunction<double Function(spine_event)>();

  int spine_event_get_int(
    spine_event self,
  ) {
    return _spine_event_get_int(
      self,
    );
  }

  late final _spine_event_get_intPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_event)>>(
          'spine_event_get_int');
  late final _spine_event_get_int =
      _spine_event_get_intPtr.asFunction<int Function(spine_event)>();

  void spine_event_set_int(
    spine_event self,
    int inValue,
  ) {
    return _spine_event_set_int(
      self,
      inValue,
    );
  }

  late final _spine_event_set_intPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Int)>>(
          'spine_event_set_int');
  late final _spine_event_set_int =
      _spine_event_set_intPtr.asFunction<void Function(spine_event, int)>();

  double spine_event_get_float(
    spine_event self,
  ) {
    return _spine_event_get_float(
      self,
    );
  }

  late final _spine_event_get_floatPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
          'spine_event_get_float');
  late final _spine_event_get_float =
      _spine_event_get_floatPtr.asFunction<double Function(spine_event)>();

  void spine_event_set_float(
    spine_event self,
    double inValue,
  ) {
    return _spine_event_set_float(
      self,
      inValue,
    );
  }

  late final _spine_event_set_floatPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Float)>>(
          'spine_event_set_float');
  late final _spine_event_set_float = _spine_event_set_floatPtr
      .asFunction<void Function(spine_event, double)>();

  ffi.Pointer<ffi.Char> spine_event_get_string(
    spine_event self,
  ) {
    return _spine_event_get_string(
      self,
    );
  }

  late final _spine_event_get_stringPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_event)>>(
          'spine_event_get_string');
  late final _spine_event_get_string = _spine_event_get_stringPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_event)>();

  void spine_event_set_string(
    spine_event self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_event_set_string(
      self,
      inValue,
    );
  }

  late final _spine_event_set_stringPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_event, ffi.Pointer<ffi.Char>)>>('spine_event_set_string');
  late final _spine_event_set_string = _spine_event_set_stringPtr
      .asFunction<void Function(spine_event, ffi.Pointer<ffi.Char>)>();

  double spine_event_get_volume(
    spine_event self,
  ) {
    return _spine_event_get_volume(
      self,
    );
  }

  late final _spine_event_get_volumePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
          'spine_event_get_volume');
  late final _spine_event_get_volume =
      _spine_event_get_volumePtr.asFunction<double Function(spine_event)>();

  void spine_event_set_volume(
    spine_event self,
    double inValue,
  ) {
    return _spine_event_set_volume(
      self,
      inValue,
    );
  }

  late final _spine_event_set_volumePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Float)>>(
          'spine_event_set_volume');
  late final _spine_event_set_volume = _spine_event_set_volumePtr
      .asFunction<void Function(spine_event, double)>();

  double spine_event_get_balance(
    spine_event self,
  ) {
    return _spine_event_get_balance(
      self,
    );
  }

  late final _spine_event_get_balancePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
          'spine_event_get_balance');
  late final _spine_event_get_balance =
      _spine_event_get_balancePtr.asFunction<double Function(spine_event)>();

  void spine_event_set_balance(
    spine_event self,
    double inValue,
  ) {
    return _spine_event_set_balance(
      self,
      inValue,
    );
  }

  late final _spine_event_set_balancePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Float)>>(
          'spine_event_set_balance');
  late final _spine_event_set_balance = _spine_event_set_balancePtr
      .asFunction<void Function(spine_event, double)>();

  spine_event_data spine_event_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_event_data_create(
      name,
    );
  }

  late final _spine_event_data_createPtr = _lookup<
          ffi.NativeFunction<spine_event_data Function(ffi.Pointer<ffi.Char>)>>(
      'spine_event_data_create');
  late final _spine_event_data_create = _spine_event_data_createPtr
      .asFunction<spine_event_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_event_data_dispose(
    spine_event_data self,
  ) {
    return _spine_event_data_dispose(
      self,
    );
  }

  late final _spine_event_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data)>>(
          'spine_event_data_dispose');
  late final _spine_event_data_dispose = _spine_event_data_disposePtr
      .asFunction<void Function(spine_event_data)>();

  ffi.Pointer<ffi.Char> spine_event_data_get_name(
    spine_event_data self,
  ) {
    return _spine_event_data_get_name(
      self,
    );
  }

  late final _spine_event_data_get_namePtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_event_data)>>(
      'spine_event_data_get_name');
  late final _spine_event_data_get_name = _spine_event_data_get_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_event_data)>();

  int spine_event_data_get_int(
    spine_event_data self,
  ) {
    return _spine_event_data_get_int(
      self,
    );
  }

  late final _spine_event_data_get_intPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_event_data)>>(
          'spine_event_data_get_int');
  late final _spine_event_data_get_int =
      _spine_event_data_get_intPtr.asFunction<int Function(spine_event_data)>();

  void spine_event_data_set_int(
    spine_event_data self,
    int inValue,
  ) {
    return _spine_event_data_set_int(
      self,
      inValue,
    );
  }

  late final _spine_event_data_set_intPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Int)>>(
          'spine_event_data_set_int');
  late final _spine_event_data_set_int = _spine_event_data_set_intPtr
      .asFunction<void Function(spine_event_data, int)>();

  double spine_event_data_get_float(
    spine_event_data self,
  ) {
    return _spine_event_data_get_float(
      self,
    );
  }

  late final _spine_event_data_get_floatPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event_data)>>(
          'spine_event_data_get_float');
  late final _spine_event_data_get_float = _spine_event_data_get_floatPtr
      .asFunction<double Function(spine_event_data)>();

  void spine_event_data_set_float(
    spine_event_data self,
    double inValue,
  ) {
    return _spine_event_data_set_float(
      self,
      inValue,
    );
  }

  late final _spine_event_data_set_floatPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Float)>>(
      'spine_event_data_set_float');
  late final _spine_event_data_set_float = _spine_event_data_set_floatPtr
      .asFunction<void Function(spine_event_data, double)>();

  ffi.Pointer<ffi.Char> spine_event_data_get_string(
    spine_event_data self,
  ) {
    return _spine_event_data_get_string(
      self,
    );
  }

  late final _spine_event_data_get_stringPtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_event_data)>>(
      'spine_event_data_get_string');
  late final _spine_event_data_get_string = _spine_event_data_get_stringPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_event_data)>();

  void spine_event_data_set_string(
    spine_event_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_event_data_set_string(
      self,
      inValue,
    );
  }

  late final _spine_event_data_set_stringPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_event_data,
              ffi.Pointer<ffi.Char>)>>('spine_event_data_set_string');
  late final _spine_event_data_set_string = _spine_event_data_set_stringPtr
      .asFunction<void Function(spine_event_data, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> spine_event_data_get_audio_path(
    spine_event_data self,
  ) {
    return _spine_event_data_get_audio_path(
      self,
    );
  }

  late final _spine_event_data_get_audio_pathPtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_event_data)>>(
      'spine_event_data_get_audio_path');
  late final _spine_event_data_get_audio_path =
      _spine_event_data_get_audio_pathPtr
          .asFunction<ffi.Pointer<ffi.Char> Function(spine_event_data)>();

  void spine_event_data_set_audio_path(
    spine_event_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_event_data_set_audio_path(
      self,
      inValue,
    );
  }

  late final _spine_event_data_set_audio_pathPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_event_data,
              ffi.Pointer<ffi.Char>)>>('spine_event_data_set_audio_path');
  late final _spine_event_data_set_audio_path =
      _spine_event_data_set_audio_pathPtr
          .asFunction<void Function(spine_event_data, ffi.Pointer<ffi.Char>)>();

  double spine_event_data_get_volume(
    spine_event_data self,
  ) {
    return _spine_event_data_get_volume(
      self,
    );
  }

  late final _spine_event_data_get_volumePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event_data)>>(
          'spine_event_data_get_volume');
  late final _spine_event_data_get_volume = _spine_event_data_get_volumePtr
      .asFunction<double Function(spine_event_data)>();

  void spine_event_data_set_volume(
    spine_event_data self,
    double inValue,
  ) {
    return _spine_event_data_set_volume(
      self,
      inValue,
    );
  }

  late final _spine_event_data_set_volumePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Float)>>(
      'spine_event_data_set_volume');
  late final _spine_event_data_set_volume = _spine_event_data_set_volumePtr
      .asFunction<void Function(spine_event_data, double)>();

  double spine_event_data_get_balance(
    spine_event_data self,
  ) {
    return _spine_event_data_get_balance(
      self,
    );
  }

  late final _spine_event_data_get_balancePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event_data)>>(
          'spine_event_data_get_balance');
  late final _spine_event_data_get_balance = _spine_event_data_get_balancePtr
      .asFunction<double Function(spine_event_data)>();

  void spine_event_data_set_balance(
    spine_event_data self,
    double inValue,
  ) {
    return _spine_event_data_set_balance(
      self,
      inValue,
    );
  }

  late final _spine_event_data_set_balancePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Float)>>(
      'spine_event_data_set_balance');
  late final _spine_event_data_set_balance = _spine_event_data_set_balancePtr
      .asFunction<void Function(spine_event_data, double)>();

  spine_event_queue_entry spine_event_queue_entry_create(
    int eventType,
    spine_track_entry trackEntry,
    spine_event event,
  ) {
    return _spine_event_queue_entry_create(
      eventType,
      trackEntry,
      event,
    );
  }

  late final _spine_event_queue_entry_createPtr = _lookup<
      ffi.NativeFunction<
          spine_event_queue_entry Function(ffi.Int32, spine_track_entry,
              spine_event)>>('spine_event_queue_entry_create');
  late final _spine_event_queue_entry_create =
      _spine_event_queue_entry_createPtr.asFunction<
          spine_event_queue_entry Function(
              int, spine_track_entry, spine_event)>();

  void spine_event_queue_entry_dispose(
    spine_event_queue_entry self,
  ) {
    return _spine_event_queue_entry_dispose(
      self,
    );
  }

  late final _spine_event_queue_entry_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_queue_entry)>>(
          'spine_event_queue_entry_dispose');
  late final _spine_event_queue_entry_dispose =
      _spine_event_queue_entry_disposePtr
          .asFunction<void Function(spine_event_queue_entry)>();

  int spine_event_queue_entry_get__type(
    spine_event_queue_entry self,
  ) {
    return _spine_event_queue_entry_get__type(
      self,
    );
  }

  late final _spine_event_queue_entry_get__typePtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_event_queue_entry)>>(
          'spine_event_queue_entry_get__type');
  late final _spine_event_queue_entry_get__type =
      _spine_event_queue_entry_get__typePtr
          .asFunction<int Function(spine_event_queue_entry)>();

  void spine_event_queue_entry_set__type(
    spine_event_queue_entry self,
    int value,
  ) {
    return _spine_event_queue_entry_set__type(
      self,
      value,
    );
  }

  late final _spine_event_queue_entry_set__typePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_event_queue_entry,
              ffi.Int32)>>('spine_event_queue_entry_set__type');
  late final _spine_event_queue_entry_set__type =
      _spine_event_queue_entry_set__typePtr
          .asFunction<void Function(spine_event_queue_entry, int)>();

  spine_track_entry spine_event_queue_entry_get__entry(
    spine_event_queue_entry self,
  ) {
    return _spine_event_queue_entry_get__entry(
      self,
    );
  }

  late final _spine_event_queue_entry_get__entryPtr = _lookup<
          ffi
          .NativeFunction<spine_track_entry Function(spine_event_queue_entry)>>(
      'spine_event_queue_entry_get__entry');
  late final _spine_event_queue_entry_get__entry =
      _spine_event_queue_entry_get__entryPtr
          .asFunction<spine_track_entry Function(spine_event_queue_entry)>();

  void spine_event_queue_entry_set__entry(
    spine_event_queue_entry self,
    spine_track_entry value,
  ) {
    return _spine_event_queue_entry_set__entry(
      self,
      value,
    );
  }

  late final _spine_event_queue_entry_set__entryPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_event_queue_entry,
              spine_track_entry)>>('spine_event_queue_entry_set__entry');
  late final _spine_event_queue_entry_set__entry =
      _spine_event_queue_entry_set__entryPtr.asFunction<
          void Function(spine_event_queue_entry, spine_track_entry)>();

  spine_event spine_event_queue_entry_get__event(
    spine_event_queue_entry self,
  ) {
    return _spine_event_queue_entry_get__event(
      self,
    );
  }

  late final _spine_event_queue_entry_get__eventPtr = _lookup<
          ffi.NativeFunction<spine_event Function(spine_event_queue_entry)>>(
      'spine_event_queue_entry_get__event');
  late final _spine_event_queue_entry_get__event =
      _spine_event_queue_entry_get__eventPtr
          .asFunction<spine_event Function(spine_event_queue_entry)>();

  void spine_event_queue_entry_set__event(
    spine_event_queue_entry self,
    spine_event value,
  ) {
    return _spine_event_queue_entry_set__event(
      self,
      value,
    );
  }

  late final _spine_event_queue_entry_set__eventPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_event_queue_entry,
              spine_event)>>('spine_event_queue_entry_set__event');
  late final _spine_event_queue_entry_set__event =
      _spine_event_queue_entry_set__eventPtr
          .asFunction<void Function(spine_event_queue_entry, spine_event)>();

  spine_event_timeline spine_event_timeline_create(
    int frameCount,
  ) {
    return _spine_event_timeline_create(
      frameCount,
    );
  }

  late final _spine_event_timeline_createPtr =
      _lookup<ffi.NativeFunction<spine_event_timeline Function(ffi.Size)>>(
          'spine_event_timeline_create');
  late final _spine_event_timeline_create = _spine_event_timeline_createPtr
      .asFunction<spine_event_timeline Function(int)>();

  void spine_event_timeline_dispose(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_dispose(
      self,
    );
  }

  late final _spine_event_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_event_timeline)>>(
          'spine_event_timeline_dispose');
  late final _spine_event_timeline_dispose = _spine_event_timeline_disposePtr
      .asFunction<void Function(spine_event_timeline)>();

  spine_rtti spine_event_timeline_get_rtti(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_rtti(
      self,
    );
  }

  late final _spine_event_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_event_timeline)>>(
          'spine_event_timeline_get_rtti');
  late final _spine_event_timeline_get_rtti = _spine_event_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_event_timeline)>();

  void spine_event_timeline_apply(
    spine_event_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_event_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_event_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_event_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_event_timeline_apply');
  late final _spine_event_timeline_apply =
      _spine_event_timeline_applyPtr.asFunction<
          void Function(spine_event_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  int spine_event_timeline_get_frame_count(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_event_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_event_timeline)>>(
          'spine_event_timeline_get_frame_count');
  late final _spine_event_timeline_get_frame_count =
      _spine_event_timeline_get_frame_countPtr
          .asFunction<int Function(spine_event_timeline)>();

  spine_array_event spine_event_timeline_get_events(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_events(
      self,
    );
  }

  late final _spine_event_timeline_get_eventsPtr = _lookup<
          ffi.NativeFunction<spine_array_event Function(spine_event_timeline)>>(
      'spine_event_timeline_get_events');
  late final _spine_event_timeline_get_events =
      _spine_event_timeline_get_eventsPtr
          .asFunction<spine_array_event Function(spine_event_timeline)>();

  void spine_event_timeline_set_frame(
    spine_event_timeline self,
    int frame,
    spine_event event,
  ) {
    return _spine_event_timeline_set_frame(
      self,
      frame,
      event,
    );
  }

  late final _spine_event_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_event_timeline, ffi.Size,
              spine_event)>>('spine_event_timeline_set_frame');
  late final _spine_event_timeline_set_frame =
      _spine_event_timeline_set_framePtr
          .asFunction<void Function(spine_event_timeline, int, spine_event)>();

  int spine_event_timeline_get_frame_entries(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_event_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_event_timeline)>>(
          'spine_event_timeline_get_frame_entries');
  late final _spine_event_timeline_get_frame_entries =
      _spine_event_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_event_timeline)>();

  spine_array_float spine_event_timeline_get_frames(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_frames(
      self,
    );
  }

  late final _spine_event_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_event_timeline)>>(
      'spine_event_timeline_get_frames');
  late final _spine_event_timeline_get_frames =
      _spine_event_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_event_timeline)>();

  double spine_event_timeline_get_duration(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_duration(
      self,
    );
  }

  late final _spine_event_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event_timeline)>>(
          'spine_event_timeline_get_duration');
  late final _spine_event_timeline_get_duration =
      _spine_event_timeline_get_durationPtr
          .asFunction<double Function(spine_event_timeline)>();

  spine_array_property_id spine_event_timeline_get_property_ids(
    spine_event_timeline self,
  ) {
    return _spine_event_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_event_timeline_get_property_idsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_property_id Function(
              spine_event_timeline)>>('spine_event_timeline_get_property_ids');
  late final _spine_event_timeline_get_property_ids =
      _spine_event_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_event_timeline)>();

  spine_rtti spine_event_timeline_rtti() {
    return _spine_event_timeline_rtti();
  }

  late final _spine_event_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_event_timeline_rtti');
  late final _spine_event_timeline_rtti =
      _spine_event_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_from_property_dispose(
    spine_from_property self,
  ) {
    return _spine_from_property_dispose(
      self,
    );
  }

  late final _spine_from_property_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_property)>>(
          'spine_from_property_dispose');
  late final _spine_from_property_dispose = _spine_from_property_disposePtr
      .asFunction<void Function(spine_from_property)>();

  spine_rtti spine_from_property_get_rtti(
    spine_from_property self,
  ) {
    return _spine_from_property_get_rtti(
      self,
    );
  }

  late final _spine_from_property_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_property)>>(
          'spine_from_property_get_rtti');
  late final _spine_from_property_get_rtti = _spine_from_property_get_rttiPtr
      .asFunction<spine_rtti Function(spine_from_property)>();

  double spine_from_property_value(
    spine_from_property self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_property_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_property_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_from_property,
              spine_skeleton,
              spine_bone_pose,
              ffi.Bool,
              ffi.Pointer<ffi.Float>)>>('spine_from_property_value');
  late final _spine_from_property_value =
      _spine_from_property_valuePtr.asFunction<
          double Function(spine_from_property, spine_skeleton, spine_bone_pose,
              bool, ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_property_rtti() {
    return _spine_from_property_rtti();
  }

  late final _spine_from_property_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_from_property_rtti');
  late final _spine_from_property_rtti =
      _spine_from_property_rttiPtr.asFunction<spine_rtti Function()>();

  double spine_from_property_get__offset(
    spine_from_property self,
  ) {
    return _spine_from_property_get__offset(
      self,
    );
  }

  late final _spine_from_property_get__offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_from_property)>>(
          'spine_from_property_get__offset');
  late final _spine_from_property_get__offset =
      _spine_from_property_get__offsetPtr
          .asFunction<double Function(spine_from_property)>();

  void spine_from_property_set__offset(
    spine_from_property self,
    double value,
  ) {
    return _spine_from_property_set__offset(
      self,
      value,
    );
  }

  late final _spine_from_property_set__offsetPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_from_property, ffi.Float)>>(
      'spine_from_property_set__offset');
  late final _spine_from_property_set__offset =
      _spine_from_property_set__offsetPtr
          .asFunction<void Function(spine_from_property, double)>();

  spine_array_to_property spine_from_property_get__to(
    spine_from_property self,
  ) {
    return _spine_from_property_get__to(
      self,
    );
  }

  late final _spine_from_property_get__toPtr = _lookup<
      ffi.NativeFunction<
          spine_array_to_property Function(
              spine_from_property)>>('spine_from_property_get__to');
  late final _spine_from_property_get__to = _spine_from_property_get__toPtr
      .asFunction<spine_array_to_property Function(spine_from_property)>();

  void spine_from_property_set__to(
    spine_from_property self,
    spine_array_to_property value,
  ) {
    return _spine_from_property_set__to(
      self,
      value,
    );
  }

  late final _spine_from_property_set__toPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_from_property,
              spine_array_to_property)>>('spine_from_property_set__to');
  late final _spine_from_property_set__to =
      _spine_from_property_set__toPtr.asFunction<
          void Function(spine_from_property, spine_array_to_property)>();

  spine_from_rotate spine_from_rotate_create() {
    return _spine_from_rotate_create();
  }

  late final _spine_from_rotate_createPtr =
      _lookup<ffi.NativeFunction<spine_from_rotate Function()>>(
          'spine_from_rotate_create');
  late final _spine_from_rotate_create =
      _spine_from_rotate_createPtr.asFunction<spine_from_rotate Function()>();

  void spine_from_rotate_dispose(
    spine_from_rotate self,
  ) {
    return _spine_from_rotate_dispose(
      self,
    );
  }

  late final _spine_from_rotate_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_rotate)>>(
          'spine_from_rotate_dispose');
  late final _spine_from_rotate_dispose = _spine_from_rotate_disposePtr
      .asFunction<void Function(spine_from_rotate)>();

  spine_rtti spine_from_rotate_get_rtti(
    spine_from_rotate self,
  ) {
    return _spine_from_rotate_get_rtti(
      self,
    );
  }

  late final _spine_from_rotate_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_rotate)>>(
          'spine_from_rotate_get_rtti');
  late final _spine_from_rotate_get_rtti = _spine_from_rotate_get_rttiPtr
      .asFunction<spine_rtti Function(spine_from_rotate)>();

  double spine_from_rotate_value(
    spine_from_rotate self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_rotate_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_rotate_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_from_rotate, spine_skeleton, spine_bone_pose,
              ffi.Bool, ffi.Pointer<ffi.Float>)>>('spine_from_rotate_value');
  late final _spine_from_rotate_value = _spine_from_rotate_valuePtr.asFunction<
      double Function(spine_from_rotate, spine_skeleton, spine_bone_pose, bool,
          ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_rotate_rtti() {
    return _spine_from_rotate_rtti();
  }

  late final _spine_from_rotate_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_from_rotate_rtti');
  late final _spine_from_rotate_rtti =
      _spine_from_rotate_rttiPtr.asFunction<spine_rtti Function()>();

  spine_from_scale_x spine_from_scale_x_create() {
    return _spine_from_scale_x_create();
  }

  late final _spine_from_scale_x_createPtr =
      _lookup<ffi.NativeFunction<spine_from_scale_x Function()>>(
          'spine_from_scale_x_create');
  late final _spine_from_scale_x_create =
      _spine_from_scale_x_createPtr.asFunction<spine_from_scale_x Function()>();

  void spine_from_scale_x_dispose(
    spine_from_scale_x self,
  ) {
    return _spine_from_scale_x_dispose(
      self,
    );
  }

  late final _spine_from_scale_x_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_scale_x)>>(
          'spine_from_scale_x_dispose');
  late final _spine_from_scale_x_dispose = _spine_from_scale_x_disposePtr
      .asFunction<void Function(spine_from_scale_x)>();

  spine_rtti spine_from_scale_x_get_rtti(
    spine_from_scale_x self,
  ) {
    return _spine_from_scale_x_get_rtti(
      self,
    );
  }

  late final _spine_from_scale_x_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_scale_x)>>(
          'spine_from_scale_x_get_rtti');
  late final _spine_from_scale_x_get_rtti = _spine_from_scale_x_get_rttiPtr
      .asFunction<spine_rtti Function(spine_from_scale_x)>();

  double spine_from_scale_x_value(
    spine_from_scale_x self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_scale_x_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_scale_x_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_from_scale_x,
              spine_skeleton,
              spine_bone_pose,
              ffi.Bool,
              ffi.Pointer<ffi.Float>)>>('spine_from_scale_x_value');
  late final _spine_from_scale_x_value =
      _spine_from_scale_x_valuePtr.asFunction<
          double Function(spine_from_scale_x, spine_skeleton, spine_bone_pose,
              bool, ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_scale_x_rtti() {
    return _spine_from_scale_x_rtti();
  }

  late final _spine_from_scale_x_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_from_scale_x_rtti');
  late final _spine_from_scale_x_rtti =
      _spine_from_scale_x_rttiPtr.asFunction<spine_rtti Function()>();

  spine_from_scale_y spine_from_scale_y_create() {
    return _spine_from_scale_y_create();
  }

  late final _spine_from_scale_y_createPtr =
      _lookup<ffi.NativeFunction<spine_from_scale_y Function()>>(
          'spine_from_scale_y_create');
  late final _spine_from_scale_y_create =
      _spine_from_scale_y_createPtr.asFunction<spine_from_scale_y Function()>();

  void spine_from_scale_y_dispose(
    spine_from_scale_y self,
  ) {
    return _spine_from_scale_y_dispose(
      self,
    );
  }

  late final _spine_from_scale_y_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_scale_y)>>(
          'spine_from_scale_y_dispose');
  late final _spine_from_scale_y_dispose = _spine_from_scale_y_disposePtr
      .asFunction<void Function(spine_from_scale_y)>();

  spine_rtti spine_from_scale_y_get_rtti(
    spine_from_scale_y self,
  ) {
    return _spine_from_scale_y_get_rtti(
      self,
    );
  }

  late final _spine_from_scale_y_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_scale_y)>>(
          'spine_from_scale_y_get_rtti');
  late final _spine_from_scale_y_get_rtti = _spine_from_scale_y_get_rttiPtr
      .asFunction<spine_rtti Function(spine_from_scale_y)>();

  double spine_from_scale_y_value(
    spine_from_scale_y self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_scale_y_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_scale_y_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_from_scale_y,
              spine_skeleton,
              spine_bone_pose,
              ffi.Bool,
              ffi.Pointer<ffi.Float>)>>('spine_from_scale_y_value');
  late final _spine_from_scale_y_value =
      _spine_from_scale_y_valuePtr.asFunction<
          double Function(spine_from_scale_y, spine_skeleton, spine_bone_pose,
              bool, ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_scale_y_rtti() {
    return _spine_from_scale_y_rtti();
  }

  late final _spine_from_scale_y_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_from_scale_y_rtti');
  late final _spine_from_scale_y_rtti =
      _spine_from_scale_y_rttiPtr.asFunction<spine_rtti Function()>();

  spine_from_shear_y spine_from_shear_y_create() {
    return _spine_from_shear_y_create();
  }

  late final _spine_from_shear_y_createPtr =
      _lookup<ffi.NativeFunction<spine_from_shear_y Function()>>(
          'spine_from_shear_y_create');
  late final _spine_from_shear_y_create =
      _spine_from_shear_y_createPtr.asFunction<spine_from_shear_y Function()>();

  void spine_from_shear_y_dispose(
    spine_from_shear_y self,
  ) {
    return _spine_from_shear_y_dispose(
      self,
    );
  }

  late final _spine_from_shear_y_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_shear_y)>>(
          'spine_from_shear_y_dispose');
  late final _spine_from_shear_y_dispose = _spine_from_shear_y_disposePtr
      .asFunction<void Function(spine_from_shear_y)>();

  spine_rtti spine_from_shear_y_get_rtti(
    spine_from_shear_y self,
  ) {
    return _spine_from_shear_y_get_rtti(
      self,
    );
  }

  late final _spine_from_shear_y_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_shear_y)>>(
          'spine_from_shear_y_get_rtti');
  late final _spine_from_shear_y_get_rtti = _spine_from_shear_y_get_rttiPtr
      .asFunction<spine_rtti Function(spine_from_shear_y)>();

  double spine_from_shear_y_value(
    spine_from_shear_y self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_shear_y_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_shear_y_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_from_shear_y,
              spine_skeleton,
              spine_bone_pose,
              ffi.Bool,
              ffi.Pointer<ffi.Float>)>>('spine_from_shear_y_value');
  late final _spine_from_shear_y_value =
      _spine_from_shear_y_valuePtr.asFunction<
          double Function(spine_from_shear_y, spine_skeleton, spine_bone_pose,
              bool, ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_shear_y_rtti() {
    return _spine_from_shear_y_rtti();
  }

  late final _spine_from_shear_y_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_from_shear_y_rtti');
  late final _spine_from_shear_y_rtti =
      _spine_from_shear_y_rttiPtr.asFunction<spine_rtti Function()>();

  spine_from_x spine_from_x_create() {
    return _spine_from_x_create();
  }

  late final _spine_from_x_createPtr =
      _lookup<ffi.NativeFunction<spine_from_x Function()>>(
          'spine_from_x_create');
  late final _spine_from_x_create =
      _spine_from_x_createPtr.asFunction<spine_from_x Function()>();

  void spine_from_x_dispose(
    spine_from_x self,
  ) {
    return _spine_from_x_dispose(
      self,
    );
  }

  late final _spine_from_x_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_x)>>(
          'spine_from_x_dispose');
  late final _spine_from_x_dispose =
      _spine_from_x_disposePtr.asFunction<void Function(spine_from_x)>();

  spine_rtti spine_from_x_get_rtti(
    spine_from_x self,
  ) {
    return _spine_from_x_get_rtti(
      self,
    );
  }

  late final _spine_from_x_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_x)>>(
          'spine_from_x_get_rtti');
  late final _spine_from_x_get_rtti =
      _spine_from_x_get_rttiPtr.asFunction<spine_rtti Function(spine_from_x)>();

  double spine_from_x_value(
    spine_from_x self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_x_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_x_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_from_x, spine_skeleton, spine_bone_pose,
              ffi.Bool, ffi.Pointer<ffi.Float>)>>('spine_from_x_value');
  late final _spine_from_x_value = _spine_from_x_valuePtr.asFunction<
      double Function(spine_from_x, spine_skeleton, spine_bone_pose, bool,
          ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_x_rtti() {
    return _spine_from_x_rtti();
  }

  late final _spine_from_x_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_from_x_rtti');
  late final _spine_from_x_rtti =
      _spine_from_x_rttiPtr.asFunction<spine_rtti Function()>();

  spine_from_y spine_from_y_create() {
    return _spine_from_y_create();
  }

  late final _spine_from_y_createPtr =
      _lookup<ffi.NativeFunction<spine_from_y Function()>>(
          'spine_from_y_create');
  late final _spine_from_y_create =
      _spine_from_y_createPtr.asFunction<spine_from_y Function()>();

  void spine_from_y_dispose(
    spine_from_y self,
  ) {
    return _spine_from_y_dispose(
      self,
    );
  }

  late final _spine_from_y_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_from_y)>>(
          'spine_from_y_dispose');
  late final _spine_from_y_dispose =
      _spine_from_y_disposePtr.asFunction<void Function(spine_from_y)>();

  spine_rtti spine_from_y_get_rtti(
    spine_from_y self,
  ) {
    return _spine_from_y_get_rtti(
      self,
    );
  }

  late final _spine_from_y_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_from_y)>>(
          'spine_from_y_get_rtti');
  late final _spine_from_y_get_rtti =
      _spine_from_y_get_rttiPtr.asFunction<spine_rtti Function(spine_from_y)>();

  double spine_from_y_value(
    spine_from_y self,
    spine_skeleton skeleton,
    spine_bone_pose source,
    bool local,
    ffi.Pointer<ffi.Float> offsets,
  ) {
    return _spine_from_y_value(
      self,
      skeleton,
      source,
      local,
      offsets,
    );
  }

  late final _spine_from_y_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_from_y, spine_skeleton, spine_bone_pose,
              ffi.Bool, ffi.Pointer<ffi.Float>)>>('spine_from_y_value');
  late final _spine_from_y_value = _spine_from_y_valuePtr.asFunction<
      double Function(spine_from_y, spine_skeleton, spine_bone_pose, bool,
          ffi.Pointer<ffi.Float>)>();

  spine_rtti spine_from_y_rtti() {
    return _spine_from_y_rtti();
  }

  late final _spine_from_y_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_from_y_rtti');
  late final _spine_from_y_rtti =
      _spine_from_y_rttiPtr.asFunction<spine_rtti Function()>();

  spine_ik_constraint spine_ik_constraint_create(
    spine_ik_constraint_data data,
    spine_skeleton skeleton,
  ) {
    return _spine_ik_constraint_create(
      data,
      skeleton,
    );
  }

  late final _spine_ik_constraint_createPtr = _lookup<
      ffi.NativeFunction<
          spine_ik_constraint Function(spine_ik_constraint_data,
              spine_skeleton)>>('spine_ik_constraint_create');
  late final _spine_ik_constraint_create =
      _spine_ik_constraint_createPtr.asFunction<
          spine_ik_constraint Function(
              spine_ik_constraint_data, spine_skeleton)>();

  void spine_ik_constraint_dispose(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_dispose(
      self,
    );
  }

  late final _spine_ik_constraint_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint)>>(
          'spine_ik_constraint_dispose');
  late final _spine_ik_constraint_dispose = _spine_ik_constraint_disposePtr
      .asFunction<void Function(spine_ik_constraint)>();

  spine_rtti spine_ik_constraint_get_rtti(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_get_rtti(
      self,
    );
  }

  late final _spine_ik_constraint_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_ik_constraint)>>(
          'spine_ik_constraint_get_rtti');
  late final _spine_ik_constraint_get_rtti = _spine_ik_constraint_get_rttiPtr
      .asFunction<spine_rtti Function(spine_ik_constraint)>();

  spine_ik_constraint spine_ik_constraint_copy(
    spine_ik_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_ik_constraint_copy(
      self,
      skeleton,
    );
  }

  late final _spine_ik_constraint_copyPtr = _lookup<
      ffi.NativeFunction<
          spine_ik_constraint Function(spine_ik_constraint,
              spine_skeleton)>>('spine_ik_constraint_copy');
  late final _spine_ik_constraint_copy =
      _spine_ik_constraint_copyPtr.asFunction<
          spine_ik_constraint Function(spine_ik_constraint, spine_skeleton)>();

  void spine_ik_constraint_update(
    spine_ik_constraint self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_ik_constraint_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_ik_constraint_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint, spine_skeleton,
              ffi.Int32)>>('spine_ik_constraint_update');
  late final _spine_ik_constraint_update = _spine_ik_constraint_updatePtr
      .asFunction<void Function(spine_ik_constraint, spine_skeleton, int)>();

  void spine_ik_constraint_sort(
    spine_ik_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_ik_constraint_sort(
      self,
      skeleton,
    );
  }

  late final _spine_ik_constraint_sortPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint,
              spine_skeleton)>>('spine_ik_constraint_sort');
  late final _spine_ik_constraint_sort = _spine_ik_constraint_sortPtr
      .asFunction<void Function(spine_ik_constraint, spine_skeleton)>();

  bool spine_ik_constraint_is_source_active(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_is_source_active(
      self,
    );
  }

  late final _spine_ik_constraint_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint)>>(
          'spine_ik_constraint_is_source_active');
  late final _spine_ik_constraint_is_source_active =
      _spine_ik_constraint_is_source_activePtr
          .asFunction<bool Function(spine_ik_constraint)>();

  spine_ik_constraint_data spine_ik_constraint_get_data(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_get_data(
      self,
    );
  }

  late final _spine_ik_constraint_get_dataPtr = _lookup<
      ffi.NativeFunction<
          spine_ik_constraint_data Function(
              spine_ik_constraint)>>('spine_ik_constraint_get_data');
  late final _spine_ik_constraint_get_data = _spine_ik_constraint_get_dataPtr
      .asFunction<spine_ik_constraint_data Function(spine_ik_constraint)>();

  spine_array_bone_pose spine_ik_constraint_get_bones(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_get_bones(
      self,
    );
  }

  late final _spine_ik_constraint_get_bonesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_bone_pose Function(spine_ik_constraint)>>(
      'spine_ik_constraint_get_bones');
  late final _spine_ik_constraint_get_bones = _spine_ik_constraint_get_bonesPtr
      .asFunction<spine_array_bone_pose Function(spine_ik_constraint)>();

  spine_bone spine_ik_constraint_get_target(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_get_target(
      self,
    );
  }

  late final _spine_ik_constraint_get_targetPtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_ik_constraint)>>(
          'spine_ik_constraint_get_target');
  late final _spine_ik_constraint_get_target =
      _spine_ik_constraint_get_targetPtr
          .asFunction<spine_bone Function(spine_ik_constraint)>();

  void spine_ik_constraint_set_target(
    spine_ik_constraint self,
    spine_bone inValue,
  ) {
    return _spine_ik_constraint_set_target(
      self,
      inValue,
    );
  }

  late final _spine_ik_constraint_set_targetPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_ik_constraint, spine_bone)>>(
      'spine_ik_constraint_set_target');
  late final _spine_ik_constraint_set_target =
      _spine_ik_constraint_set_targetPtr
          .asFunction<void Function(spine_ik_constraint, spine_bone)>();

  void spine_ik_constraint_apply_1(
    spine_skeleton skeleton,
    spine_bone_pose bone,
    double targetX,
    double targetY,
    bool compress,
    bool stretch,
    bool uniform,
    double mix,
  ) {
    return _spine_ik_constraint_apply_1(
      skeleton,
      bone,
      targetX,
      targetY,
      compress,
      stretch,
      uniform,
      mix,
    );
  }

  late final _spine_ik_constraint_apply_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_skeleton,
              spine_bone_pose,
              ffi.Float,
              ffi.Float,
              ffi.Bool,
              ffi.Bool,
              ffi.Bool,
              ffi.Float)>>('spine_ik_constraint_apply_1');
  late final _spine_ik_constraint_apply_1 =
      _spine_ik_constraint_apply_1Ptr.asFunction<
          void Function(spine_skeleton, spine_bone_pose, double, double, bool,
              bool, bool, double)>();

  void spine_ik_constraint_apply_2(
    spine_skeleton skeleton,
    spine_bone_pose parent,
    spine_bone_pose child,
    double targetX,
    double targetY,
    int bendDirection,
    bool stretch,
    bool uniform,
    double softness,
    double mix,
  ) {
    return _spine_ik_constraint_apply_2(
      skeleton,
      parent,
      child,
      targetX,
      targetY,
      bendDirection,
      stretch,
      uniform,
      softness,
      mix,
    );
  }

  late final _spine_ik_constraint_apply_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_skeleton,
              spine_bone_pose,
              spine_bone_pose,
              ffi.Float,
              ffi.Float,
              ffi.Int,
              ffi.Bool,
              ffi.Bool,
              ffi.Float,
              ffi.Float)>>('spine_ik_constraint_apply_2');
  late final _spine_ik_constraint_apply_2 =
      _spine_ik_constraint_apply_2Ptr.asFunction<
          void Function(spine_skeleton, spine_bone_pose, spine_bone_pose,
              double, double, int, bool, bool, double, double)>();

  spine_ik_constraint_pose spine_ik_constraint_get_pose(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_get_pose(
      self,
    );
  }

  late final _spine_ik_constraint_get_posePtr = _lookup<
      ffi.NativeFunction<
          spine_ik_constraint_pose Function(
              spine_ik_constraint)>>('spine_ik_constraint_get_pose');
  late final _spine_ik_constraint_get_pose = _spine_ik_constraint_get_posePtr
      .asFunction<spine_ik_constraint_pose Function(spine_ik_constraint)>();

  spine_ik_constraint_pose spine_ik_constraint_get_applied_pose(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_get_applied_pose(
      self,
    );
  }

  late final _spine_ik_constraint_get_applied_posePtr = _lookup<
      ffi.NativeFunction<
          spine_ik_constraint_pose Function(
              spine_ik_constraint)>>('spine_ik_constraint_get_applied_pose');
  late final _spine_ik_constraint_get_applied_pose =
      _spine_ik_constraint_get_applied_posePtr
          .asFunction<spine_ik_constraint_pose Function(spine_ik_constraint)>();

  void spine_ik_constraint_reset_constrained(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_reset_constrained(
      self,
    );
  }

  late final _spine_ik_constraint_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint)>>(
          'spine_ik_constraint_reset_constrained');
  late final _spine_ik_constraint_reset_constrained =
      _spine_ik_constraint_reset_constrainedPtr
          .asFunction<void Function(spine_ik_constraint)>();

  void spine_ik_constraint_constrained(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_constrained(
      self,
    );
  }

  late final _spine_ik_constraint_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint)>>(
          'spine_ik_constraint_constrained');
  late final _spine_ik_constraint_constrained =
      _spine_ik_constraint_constrainedPtr
          .asFunction<void Function(spine_ik_constraint)>();

  bool spine_ik_constraint_is_pose_equal_to_applied(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_ik_constraint_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint)>>(
          'spine_ik_constraint_is_pose_equal_to_applied');
  late final _spine_ik_constraint_is_pose_equal_to_applied =
      _spine_ik_constraint_is_pose_equal_to_appliedPtr
          .asFunction<bool Function(spine_ik_constraint)>();

  bool spine_ik_constraint_is_active(
    spine_ik_constraint self,
  ) {
    return _spine_ik_constraint_is_active(
      self,
    );
  }

  late final _spine_ik_constraint_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint)>>(
          'spine_ik_constraint_is_active');
  late final _spine_ik_constraint_is_active = _spine_ik_constraint_is_activePtr
      .asFunction<bool Function(spine_ik_constraint)>();

  void spine_ik_constraint_set_active(
    spine_ik_constraint self,
    bool active,
  ) {
    return _spine_ik_constraint_set_active(
      self,
      active,
    );
  }

  late final _spine_ik_constraint_set_activePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, ffi.Bool)>>(
      'spine_ik_constraint_set_active');
  late final _spine_ik_constraint_set_active =
      _spine_ik_constraint_set_activePtr
          .asFunction<void Function(spine_ik_constraint, bool)>();

  spine_rtti spine_ik_constraint_rtti() {
    return _spine_ik_constraint_rtti();
  }

  late final _spine_ik_constraint_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_ik_constraint_rtti');
  late final _spine_ik_constraint_rtti =
      _spine_ik_constraint_rttiPtr.asFunction<spine_rtti Function()>();

  spine_ik_constraint_data spine_ik_constraint_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_ik_constraint_data_create(
      name,
    );
  }

  late final _spine_ik_constraint_data_createPtr = _lookup<
      ffi.NativeFunction<
          spine_ik_constraint_data Function(
              ffi.Pointer<ffi.Char>)>>('spine_ik_constraint_data_create');
  late final _spine_ik_constraint_data_create =
      _spine_ik_constraint_data_createPtr.asFunction<
          spine_ik_constraint_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_ik_constraint_data_dispose(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_dispose(
      self,
    );
  }

  late final _spine_ik_constraint_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data)>>(
          'spine_ik_constraint_data_dispose');
  late final _spine_ik_constraint_data_dispose =
      _spine_ik_constraint_data_disposePtr
          .asFunction<void Function(spine_ik_constraint_data)>();

  spine_rtti spine_ik_constraint_data_get_rtti(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_rtti(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_ik_constraint_data)>>(
      'spine_ik_constraint_data_get_rtti');
  late final _spine_ik_constraint_data_get_rtti =
      _spine_ik_constraint_data_get_rttiPtr
          .asFunction<spine_rtti Function(spine_ik_constraint_data)>();

  spine_constraint spine_ik_constraint_data_create_method(
    spine_ik_constraint_data self,
    spine_skeleton skeleton,
  ) {
    return _spine_ik_constraint_data_create_method(
      self,
      skeleton,
    );
  }

  late final _spine_ik_constraint_data_create_methodPtr = _lookup<
      ffi.NativeFunction<
          spine_constraint Function(spine_ik_constraint_data,
              spine_skeleton)>>('spine_ik_constraint_data_create_method');
  late final _spine_ik_constraint_data_create_method =
      _spine_ik_constraint_data_create_methodPtr.asFunction<
          spine_constraint Function(
              spine_ik_constraint_data, spine_skeleton)>();

  spine_array_bone_data spine_ik_constraint_data_get_bones(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_bones(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_bonesPtr = _lookup<
      ffi.NativeFunction<
          spine_array_bone_data Function(
              spine_ik_constraint_data)>>('spine_ik_constraint_data_get_bones');
  late final _spine_ik_constraint_data_get_bones =
      _spine_ik_constraint_data_get_bonesPtr.asFunction<
          spine_array_bone_data Function(spine_ik_constraint_data)>();

  spine_bone_data spine_ik_constraint_data_get_target(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_target(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_targetPtr = _lookup<
          ffi
          .NativeFunction<spine_bone_data Function(spine_ik_constraint_data)>>(
      'spine_ik_constraint_data_get_target');
  late final _spine_ik_constraint_data_get_target =
      _spine_ik_constraint_data_get_targetPtr
          .asFunction<spine_bone_data Function(spine_ik_constraint_data)>();

  void spine_ik_constraint_data_set_target(
    spine_ik_constraint_data self,
    spine_bone_data inValue,
  ) {
    return _spine_ik_constraint_data_set_target(
      self,
      inValue,
    );
  }

  late final _spine_ik_constraint_data_set_targetPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_data,
              spine_bone_data)>>('spine_ik_constraint_data_set_target');
  late final _spine_ik_constraint_data_set_target =
      _spine_ik_constraint_data_set_targetPtr.asFunction<
          void Function(spine_ik_constraint_data, spine_bone_data)>();

  bool spine_ik_constraint_data_get_uniform(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_uniform(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_uniformPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint_data)>>(
          'spine_ik_constraint_data_get_uniform');
  late final _spine_ik_constraint_data_get_uniform =
      _spine_ik_constraint_data_get_uniformPtr
          .asFunction<bool Function(spine_ik_constraint_data)>();

  void spine_ik_constraint_data_set_uniform(
    spine_ik_constraint_data self,
    bool uniform,
  ) {
    return _spine_ik_constraint_data_set_uniform(
      self,
      uniform,
    );
  }

  late final _spine_ik_constraint_data_set_uniformPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_data,
              ffi.Bool)>>('spine_ik_constraint_data_set_uniform');
  late final _spine_ik_constraint_data_set_uniform =
      _spine_ik_constraint_data_set_uniformPtr
          .asFunction<void Function(spine_ik_constraint_data, bool)>();

  ffi.Pointer<ffi.Char> spine_ik_constraint_data_get_name(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_name(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              spine_ik_constraint_data)>>('spine_ik_constraint_data_get_name');
  late final _spine_ik_constraint_data_get_name =
      _spine_ik_constraint_data_get_namePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(spine_ik_constraint_data)>();

  bool spine_ik_constraint_data_get_skin_required(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_skin_required(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint_data)>>(
          'spine_ik_constraint_data_get_skin_required');
  late final _spine_ik_constraint_data_get_skin_required =
      _spine_ik_constraint_data_get_skin_requiredPtr
          .asFunction<bool Function(spine_ik_constraint_data)>();

  spine_ik_constraint_pose spine_ik_constraint_data_get_setup_pose(
    spine_ik_constraint_data self,
  ) {
    return _spine_ik_constraint_data_get_setup_pose(
      self,
    );
  }

  late final _spine_ik_constraint_data_get_setup_posePtr = _lookup<
          ffi.NativeFunction<
              spine_ik_constraint_pose Function(spine_ik_constraint_data)>>(
      'spine_ik_constraint_data_get_setup_pose');
  late final _spine_ik_constraint_data_get_setup_pose =
      _spine_ik_constraint_data_get_setup_posePtr.asFunction<
          spine_ik_constraint_pose Function(spine_ik_constraint_data)>();

  void spine_ik_constraint_data_set_skin_required(
    spine_ik_constraint_data self,
    bool skinRequired,
  ) {
    return _spine_ik_constraint_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_ik_constraint_data_set_skin_requiredPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_data,
              ffi.Bool)>>('spine_ik_constraint_data_set_skin_required');
  late final _spine_ik_constraint_data_set_skin_required =
      _spine_ik_constraint_data_set_skin_requiredPtr
          .asFunction<void Function(spine_ik_constraint_data, bool)>();

  spine_rtti spine_ik_constraint_data_rtti() {
    return _spine_ik_constraint_data_rtti();
  }

  late final _spine_ik_constraint_data_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_ik_constraint_data_rtti');
  late final _spine_ik_constraint_data_rtti =
      _spine_ik_constraint_data_rttiPtr.asFunction<spine_rtti Function()>();

  spine_ik_constraint_pose spine_ik_constraint_pose_create() {
    return _spine_ik_constraint_pose_create();
  }

  late final _spine_ik_constraint_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_ik_constraint_pose Function()>>(
          'spine_ik_constraint_pose_create');
  late final _spine_ik_constraint_pose_create =
      _spine_ik_constraint_pose_createPtr
          .asFunction<spine_ik_constraint_pose Function()>();

  void spine_ik_constraint_pose_dispose(
    spine_ik_constraint_pose self,
  ) {
    return _spine_ik_constraint_pose_dispose(
      self,
    );
  }

  late final _spine_ik_constraint_pose_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_pose)>>(
          'spine_ik_constraint_pose_dispose');
  late final _spine_ik_constraint_pose_dispose =
      _spine_ik_constraint_pose_disposePtr
          .asFunction<void Function(spine_ik_constraint_pose)>();

  void spine_ik_constraint_pose_set(
    spine_ik_constraint_pose self,
    spine_ik_constraint_pose pose,
  ) {
    return _spine_ik_constraint_pose_set(
      self,
      pose,
    );
  }

  late final _spine_ik_constraint_pose_setPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_pose,
              spine_ik_constraint_pose)>>('spine_ik_constraint_pose_set');
  late final _spine_ik_constraint_pose_set =
      _spine_ik_constraint_pose_setPtr.asFunction<
          void Function(spine_ik_constraint_pose, spine_ik_constraint_pose)>();

  double spine_ik_constraint_pose_get_mix(
    spine_ik_constraint_pose self,
  ) {
    return _spine_ik_constraint_pose_get_mix(
      self,
    );
  }

  late final _spine_ik_constraint_pose_get_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint_pose)>>(
          'spine_ik_constraint_pose_get_mix');
  late final _spine_ik_constraint_pose_get_mix =
      _spine_ik_constraint_pose_get_mixPtr
          .asFunction<double Function(spine_ik_constraint_pose)>();

  void spine_ik_constraint_pose_set_mix(
    spine_ik_constraint_pose self,
    double mix,
  ) {
    return _spine_ik_constraint_pose_set_mix(
      self,
      mix,
    );
  }

  late final _spine_ik_constraint_pose_set_mixPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_pose,
              ffi.Float)>>('spine_ik_constraint_pose_set_mix');
  late final _spine_ik_constraint_pose_set_mix =
      _spine_ik_constraint_pose_set_mixPtr
          .asFunction<void Function(spine_ik_constraint_pose, double)>();

  double spine_ik_constraint_pose_get_softness(
    spine_ik_constraint_pose self,
  ) {
    return _spine_ik_constraint_pose_get_softness(
      self,
    );
  }

  late final _spine_ik_constraint_pose_get_softnessPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint_pose)>>(
          'spine_ik_constraint_pose_get_softness');
  late final _spine_ik_constraint_pose_get_softness =
      _spine_ik_constraint_pose_get_softnessPtr
          .asFunction<double Function(spine_ik_constraint_pose)>();

  void spine_ik_constraint_pose_set_softness(
    spine_ik_constraint_pose self,
    double softness,
  ) {
    return _spine_ik_constraint_pose_set_softness(
      self,
      softness,
    );
  }

  late final _spine_ik_constraint_pose_set_softnessPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_pose,
              ffi.Float)>>('spine_ik_constraint_pose_set_softness');
  late final _spine_ik_constraint_pose_set_softness =
      _spine_ik_constraint_pose_set_softnessPtr
          .asFunction<void Function(spine_ik_constraint_pose, double)>();

  int spine_ik_constraint_pose_get_bend_direction(
    spine_ik_constraint_pose self,
  ) {
    return _spine_ik_constraint_pose_get_bend_direction(
      self,
    );
  }

  late final _spine_ik_constraint_pose_get_bend_directionPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_ik_constraint_pose)>>(
          'spine_ik_constraint_pose_get_bend_direction');
  late final _spine_ik_constraint_pose_get_bend_direction =
      _spine_ik_constraint_pose_get_bend_directionPtr
          .asFunction<int Function(spine_ik_constraint_pose)>();

  void spine_ik_constraint_pose_set_bend_direction(
    spine_ik_constraint_pose self,
    int bendDirection,
  ) {
    return _spine_ik_constraint_pose_set_bend_direction(
      self,
      bendDirection,
    );
  }

  late final _spine_ik_constraint_pose_set_bend_directionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_pose,
              ffi.Int)>>('spine_ik_constraint_pose_set_bend_direction');
  late final _spine_ik_constraint_pose_set_bend_direction =
      _spine_ik_constraint_pose_set_bend_directionPtr
          .asFunction<void Function(spine_ik_constraint_pose, int)>();

  bool spine_ik_constraint_pose_get_compress(
    spine_ik_constraint_pose self,
  ) {
    return _spine_ik_constraint_pose_get_compress(
      self,
    );
  }

  late final _spine_ik_constraint_pose_get_compressPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint_pose)>>(
          'spine_ik_constraint_pose_get_compress');
  late final _spine_ik_constraint_pose_get_compress =
      _spine_ik_constraint_pose_get_compressPtr
          .asFunction<bool Function(spine_ik_constraint_pose)>();

  void spine_ik_constraint_pose_set_compress(
    spine_ik_constraint_pose self,
    bool compress,
  ) {
    return _spine_ik_constraint_pose_set_compress(
      self,
      compress,
    );
  }

  late final _spine_ik_constraint_pose_set_compressPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_pose,
              ffi.Bool)>>('spine_ik_constraint_pose_set_compress');
  late final _spine_ik_constraint_pose_set_compress =
      _spine_ik_constraint_pose_set_compressPtr
          .asFunction<void Function(spine_ik_constraint_pose, bool)>();

  bool spine_ik_constraint_pose_get_stretch(
    spine_ik_constraint_pose self,
  ) {
    return _spine_ik_constraint_pose_get_stretch(
      self,
    );
  }

  late final _spine_ik_constraint_pose_get_stretchPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_ik_constraint_pose)>>(
          'spine_ik_constraint_pose_get_stretch');
  late final _spine_ik_constraint_pose_get_stretch =
      _spine_ik_constraint_pose_get_stretchPtr
          .asFunction<bool Function(spine_ik_constraint_pose)>();

  void spine_ik_constraint_pose_set_stretch(
    spine_ik_constraint_pose self,
    bool stretch,
  ) {
    return _spine_ik_constraint_pose_set_stretch(
      self,
      stretch,
    );
  }

  late final _spine_ik_constraint_pose_set_stretchPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_pose,
              ffi.Bool)>>('spine_ik_constraint_pose_set_stretch');
  late final _spine_ik_constraint_pose_set_stretch =
      _spine_ik_constraint_pose_set_stretchPtr
          .asFunction<void Function(spine_ik_constraint_pose, bool)>();

  spine_ik_constraint_timeline spine_ik_constraint_timeline_create(
    int frameCount,
    int bezierCount,
    int constraintIndex,
  ) {
    return _spine_ik_constraint_timeline_create(
      frameCount,
      bezierCount,
      constraintIndex,
    );
  }

  late final _spine_ik_constraint_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_ik_constraint_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_ik_constraint_timeline_create');
  late final _spine_ik_constraint_timeline_create =
      _spine_ik_constraint_timeline_createPtr
          .asFunction<spine_ik_constraint_timeline Function(int, int, int)>();

  void spine_ik_constraint_timeline_dispose(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_dispose(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_disposePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_timeline)>>(
      'spine_ik_constraint_timeline_dispose');
  late final _spine_ik_constraint_timeline_dispose =
      _spine_ik_constraint_timeline_disposePtr
          .asFunction<void Function(spine_ik_constraint_timeline)>();

  spine_rtti spine_ik_constraint_timeline_get_rtti(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_rtti(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_rttiPtr = _lookup<
          ffi
          .NativeFunction<spine_rtti Function(spine_ik_constraint_timeline)>>(
      'spine_ik_constraint_timeline_get_rtti');
  late final _spine_ik_constraint_timeline_get_rtti =
      _spine_ik_constraint_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_ik_constraint_timeline)>();

  void spine_ik_constraint_timeline_apply(
    spine_ik_constraint_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_ik_constraint_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_ik_constraint_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_ik_constraint_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_ik_constraint_timeline_apply');
  late final _spine_ik_constraint_timeline_apply =
      _spine_ik_constraint_timeline_applyPtr.asFunction<
          void Function(spine_ik_constraint_timeline, spine_skeleton, double,
              double, spine_array_event, double, int, int, bool)>();

  void spine_ik_constraint_timeline_set_frame(
    spine_ik_constraint_timeline self,
    int frame,
    double time,
    double mix,
    double softness,
    int bendDirection,
    bool compress,
    bool stretch,
  ) {
    return _spine_ik_constraint_timeline_set_frame(
      self,
      frame,
      time,
      mix,
      softness,
      bendDirection,
      compress,
      stretch,
    );
  }

  late final _spine_ik_constraint_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_ik_constraint_timeline,
              ffi.Int,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Int,
              ffi.Bool,
              ffi.Bool)>>('spine_ik_constraint_timeline_set_frame');
  late final _spine_ik_constraint_timeline_set_frame =
      _spine_ik_constraint_timeline_set_framePtr.asFunction<
          void Function(spine_ik_constraint_timeline, int, double, double,
              double, int, bool, bool)>();

  void spine_ik_constraint_timeline_set_linear(
    spine_ik_constraint_timeline self,
    int frame,
  ) {
    return _spine_ik_constraint_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_ik_constraint_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_timeline,
              ffi.Size)>>('spine_ik_constraint_timeline_set_linear');
  late final _spine_ik_constraint_timeline_set_linear =
      _spine_ik_constraint_timeline_set_linearPtr
          .asFunction<void Function(spine_ik_constraint_timeline, int)>();

  void spine_ik_constraint_timeline_set_stepped(
    spine_ik_constraint_timeline self,
    int frame,
  ) {
    return _spine_ik_constraint_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_ik_constraint_timeline_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_timeline,
              ffi.Size)>>('spine_ik_constraint_timeline_set_stepped');
  late final _spine_ik_constraint_timeline_set_stepped =
      _spine_ik_constraint_timeline_set_steppedPtr
          .asFunction<void Function(spine_ik_constraint_timeline, int)>();

  void spine_ik_constraint_timeline_set_bezier(
    spine_ik_constraint_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_ik_constraint_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_ik_constraint_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_ik_constraint_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_ik_constraint_timeline_set_bezier');
  late final _spine_ik_constraint_timeline_set_bezier =
      _spine_ik_constraint_timeline_set_bezierPtr.asFunction<
          void Function(spine_ik_constraint_timeline, int, int, double, double,
              double, double, double, double, double, double, double)>();

  double spine_ik_constraint_timeline_get_bezier_value(
    spine_ik_constraint_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_ik_constraint_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_ik_constraint_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_ik_constraint_timeline,
              ffi.Float,
              ffi.Size,
              ffi.Size,
              ffi.Size)>>('spine_ik_constraint_timeline_get_bezier_value');
  late final _spine_ik_constraint_timeline_get_bezier_value =
      _spine_ik_constraint_timeline_get_bezier_valuePtr.asFunction<
          double Function(
              spine_ik_constraint_timeline, double, int, int, int)>();

  spine_array_float spine_ik_constraint_timeline_get_curves(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_curves(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_ik_constraint_timeline)>>(
      'spine_ik_constraint_timeline_get_curves');
  late final _spine_ik_constraint_timeline_get_curves =
      _spine_ik_constraint_timeline_get_curvesPtr.asFunction<
          spine_array_float Function(spine_ik_constraint_timeline)>();

  int spine_ik_constraint_timeline_get_frame_entries(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_frame_entriesPtr = _lookup<
          ffi.NativeFunction<ffi.Size Function(spine_ik_constraint_timeline)>>(
      'spine_ik_constraint_timeline_get_frame_entries');
  late final _spine_ik_constraint_timeline_get_frame_entries =
      _spine_ik_constraint_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_ik_constraint_timeline)>();

  int spine_ik_constraint_timeline_get_frame_count(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_frame_countPtr = _lookup<
          ffi.NativeFunction<ffi.Size Function(spine_ik_constraint_timeline)>>(
      'spine_ik_constraint_timeline_get_frame_count');
  late final _spine_ik_constraint_timeline_get_frame_count =
      _spine_ik_constraint_timeline_get_frame_countPtr
          .asFunction<int Function(spine_ik_constraint_timeline)>();

  spine_array_float spine_ik_constraint_timeline_get_frames(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_frames(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_ik_constraint_timeline)>>(
      'spine_ik_constraint_timeline_get_frames');
  late final _spine_ik_constraint_timeline_get_frames =
      _spine_ik_constraint_timeline_get_framesPtr.asFunction<
          spine_array_float Function(spine_ik_constraint_timeline)>();

  double spine_ik_constraint_timeline_get_duration(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_duration(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_ik_constraint_timeline)>>(
      'spine_ik_constraint_timeline_get_duration');
  late final _spine_ik_constraint_timeline_get_duration =
      _spine_ik_constraint_timeline_get_durationPtr
          .asFunction<double Function(spine_ik_constraint_timeline)>();

  spine_array_property_id spine_ik_constraint_timeline_get_property_ids(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_ik_constraint_timeline)>>(
      'spine_ik_constraint_timeline_get_property_ids');
  late final _spine_ik_constraint_timeline_get_property_ids =
      _spine_ik_constraint_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_ik_constraint_timeline)>();

  int spine_ik_constraint_timeline_get_constraint_index(
    spine_ik_constraint_timeline self,
  ) {
    return _spine_ik_constraint_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_ik_constraint_timeline_get_constraint_indexPtr = _lookup<
          ffi.NativeFunction<ffi.Int Function(spine_ik_constraint_timeline)>>(
      'spine_ik_constraint_timeline_get_constraint_index');
  late final _spine_ik_constraint_timeline_get_constraint_index =
      _spine_ik_constraint_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_ik_constraint_timeline)>();

  void spine_ik_constraint_timeline_set_constraint_index(
    spine_ik_constraint_timeline self,
    int inValue,
  ) {
    return _spine_ik_constraint_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_ik_constraint_timeline_set_constraint_indexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_ik_constraint_timeline,
              ffi.Int)>>('spine_ik_constraint_timeline_set_constraint_index');
  late final _spine_ik_constraint_timeline_set_constraint_index =
      _spine_ik_constraint_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_ik_constraint_timeline, int)>();

  spine_rtti spine_ik_constraint_timeline_rtti() {
    return _spine_ik_constraint_timeline_rtti();
  }

  late final _spine_ik_constraint_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_ik_constraint_timeline_rtti');
  late final _spine_ik_constraint_timeline_rtti =
      _spine_ik_constraint_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_inherit_timeline spine_inherit_timeline_create(
    int frameCount,
    int boneIndex,
  ) {
    return _spine_inherit_timeline_create(
      frameCount,
      boneIndex,
    );
  }

  late final _spine_inherit_timeline_createPtr = _lookup<
          ffi
          .NativeFunction<spine_inherit_timeline Function(ffi.Size, ffi.Int)>>(
      'spine_inherit_timeline_create');
  late final _spine_inherit_timeline_create = _spine_inherit_timeline_createPtr
      .asFunction<spine_inherit_timeline Function(int, int)>();

  void spine_inherit_timeline_dispose(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_dispose(
      self,
    );
  }

  late final _spine_inherit_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_inherit_timeline)>>(
          'spine_inherit_timeline_dispose');
  late final _spine_inherit_timeline_dispose =
      _spine_inherit_timeline_disposePtr
          .asFunction<void Function(spine_inherit_timeline)>();

  spine_rtti spine_inherit_timeline_get_rtti(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_rtti(
      self,
    );
  }

  late final _spine_inherit_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_inherit_timeline)>>(
          'spine_inherit_timeline_get_rtti');
  late final _spine_inherit_timeline_get_rtti =
      _spine_inherit_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_inherit_timeline)>();

  void spine_inherit_timeline_set_frame(
    spine_inherit_timeline self,
    int frame,
    double time,
    int inherit,
  ) {
    return _spine_inherit_timeline_set_frame(
      self,
      frame,
      time,
      inherit,
    );
  }

  late final _spine_inherit_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_inherit_timeline, ffi.Int, ffi.Float,
              ffi.Int32)>>('spine_inherit_timeline_set_frame');
  late final _spine_inherit_timeline_set_frame =
      _spine_inherit_timeline_set_framePtr.asFunction<
          void Function(spine_inherit_timeline, int, double, int)>();

  void spine_inherit_timeline_apply(
    spine_inherit_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_inherit_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_inherit_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_inherit_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_inherit_timeline_apply');
  late final _spine_inherit_timeline_apply =
      _spine_inherit_timeline_applyPtr.asFunction<
          void Function(spine_inherit_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  int spine_inherit_timeline_get_frame_entries(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_inherit_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_inherit_timeline)>>(
          'spine_inherit_timeline_get_frame_entries');
  late final _spine_inherit_timeline_get_frame_entries =
      _spine_inherit_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_inherit_timeline)>();

  int spine_inherit_timeline_get_frame_count(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_inherit_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_inherit_timeline)>>(
          'spine_inherit_timeline_get_frame_count');
  late final _spine_inherit_timeline_get_frame_count =
      _spine_inherit_timeline_get_frame_countPtr
          .asFunction<int Function(spine_inherit_timeline)>();

  spine_array_float spine_inherit_timeline_get_frames(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_frames(
      self,
    );
  }

  late final _spine_inherit_timeline_get_framesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_inherit_timeline)>>(
      'spine_inherit_timeline_get_frames');
  late final _spine_inherit_timeline_get_frames =
      _spine_inherit_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_inherit_timeline)>();

  double spine_inherit_timeline_get_duration(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_duration(
      self,
    );
  }

  late final _spine_inherit_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_inherit_timeline)>>(
          'spine_inherit_timeline_get_duration');
  late final _spine_inherit_timeline_get_duration =
      _spine_inherit_timeline_get_durationPtr
          .asFunction<double Function(spine_inherit_timeline)>();

  spine_array_property_id spine_inherit_timeline_get_property_ids(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_inherit_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_inherit_timeline)>>(
      'spine_inherit_timeline_get_property_ids');
  late final _spine_inherit_timeline_get_property_ids =
      _spine_inherit_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_inherit_timeline)>();

  int spine_inherit_timeline_get_bone_index(
    spine_inherit_timeline self,
  ) {
    return _spine_inherit_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_inherit_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_inherit_timeline)>>(
          'spine_inherit_timeline_get_bone_index');
  late final _spine_inherit_timeline_get_bone_index =
      _spine_inherit_timeline_get_bone_indexPtr
          .asFunction<int Function(spine_inherit_timeline)>();

  void spine_inherit_timeline_set_bone_index(
    spine_inherit_timeline self,
    int inValue,
  ) {
    return _spine_inherit_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_inherit_timeline_set_bone_indexPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_inherit_timeline, ffi.Int)>>(
      'spine_inherit_timeline_set_bone_index');
  late final _spine_inherit_timeline_set_bone_index =
      _spine_inherit_timeline_set_bone_indexPtr
          .asFunction<void Function(spine_inherit_timeline, int)>();

  spine_rtti spine_inherit_timeline_rtti() {
    return _spine_inherit_timeline_rtti();
  }

  late final _spine_inherit_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_inherit_timeline_rtti');
  late final _spine_inherit_timeline_rtti =
      _spine_inherit_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_linked_mesh spine_linked_mesh_create(
    spine_mesh_attachment mesh,
    int skinIndex,
    int slotIndex,
    ffi.Pointer<ffi.Char> parent,
    bool inheritTimelines,
  ) {
    return _spine_linked_mesh_create(
      mesh,
      skinIndex,
      slotIndex,
      parent,
      inheritTimelines,
    );
  }

  late final _spine_linked_mesh_createPtr = _lookup<
      ffi.NativeFunction<
          spine_linked_mesh Function(spine_mesh_attachment, ffi.Int, ffi.Size,
              ffi.Pointer<ffi.Char>, ffi.Bool)>>('spine_linked_mesh_create');
  late final _spine_linked_mesh_create =
      _spine_linked_mesh_createPtr.asFunction<
          spine_linked_mesh Function(
              spine_mesh_attachment, int, int, ffi.Pointer<ffi.Char>, bool)>();

  spine_linked_mesh spine_linked_mesh_create2(
    spine_mesh_attachment mesh,
    ffi.Pointer<ffi.Char> skin,
    int slotIndex,
    ffi.Pointer<ffi.Char> parent,
    bool inheritTimelines,
  ) {
    return _spine_linked_mesh_create2(
      mesh,
      skin,
      slotIndex,
      parent,
      inheritTimelines,
    );
  }

  late final _spine_linked_mesh_create2Ptr = _lookup<
      ffi.NativeFunction<
          spine_linked_mesh Function(
              spine_mesh_attachment,
              ffi.Pointer<ffi.Char>,
              ffi.Size,
              ffi.Pointer<ffi.Char>,
              ffi.Bool)>>('spine_linked_mesh_create2');
  late final _spine_linked_mesh_create2 =
      _spine_linked_mesh_create2Ptr.asFunction<
          spine_linked_mesh Function(spine_mesh_attachment,
              ffi.Pointer<ffi.Char>, int, ffi.Pointer<ffi.Char>, bool)>();

  void spine_linked_mesh_dispose(
    spine_linked_mesh self,
  ) {
    return _spine_linked_mesh_dispose(
      self,
    );
  }

  late final _spine_linked_mesh_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_linked_mesh)>>(
          'spine_linked_mesh_dispose');
  late final _spine_linked_mesh_dispose = _spine_linked_mesh_disposePtr
      .asFunction<void Function(spine_linked_mesh)>();

  spine_mesh_attachment spine_mesh_attachment_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_mesh_attachment_create(
      name,
    );
  }

  late final _spine_mesh_attachment_createPtr = _lookup<
      ffi.NativeFunction<
          spine_mesh_attachment Function(
              ffi.Pointer<ffi.Char>)>>('spine_mesh_attachment_create');
  late final _spine_mesh_attachment_create = _spine_mesh_attachment_createPtr
      .asFunction<spine_mesh_attachment Function(ffi.Pointer<ffi.Char>)>();

  void spine_mesh_attachment_dispose(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_dispose(
      self,
    );
  }

  late final _spine_mesh_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_dispose');
  late final _spine_mesh_attachment_dispose = _spine_mesh_attachment_disposePtr
      .asFunction<void Function(spine_mesh_attachment)>();

  spine_rtti spine_mesh_attachment_get_rtti(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_rtti(
      self,
    );
  }

  late final _spine_mesh_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_rtti');
  late final _spine_mesh_attachment_get_rtti =
      _spine_mesh_attachment_get_rttiPtr
          .asFunction<spine_rtti Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_compute_world_vertices_1(
    spine_mesh_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    ffi.Pointer<ffi.Float> worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_mesh_attachment_compute_world_vertices_1(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_mesh_attachment_compute_world_vertices_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_mesh_attachment,
              spine_skeleton,
              spine_slot,
              ffi.Size,
              ffi.Size,
              ffi.Pointer<ffi.Float>,
              ffi.Size,
              ffi.Size)>>('spine_mesh_attachment_compute_world_vertices_1');
  late final _spine_mesh_attachment_compute_world_vertices_1 =
      _spine_mesh_attachment_compute_world_vertices_1Ptr.asFunction<
          void Function(spine_mesh_attachment, spine_skeleton, spine_slot, int,
              int, ffi.Pointer<ffi.Float>, int, int)>();

  void spine_mesh_attachment_compute_world_vertices_2(
    spine_mesh_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    spine_array_float worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_mesh_attachment_compute_world_vertices_2(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_mesh_attachment_compute_world_vertices_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_mesh_attachment,
              spine_skeleton,
              spine_slot,
              ffi.Size,
              ffi.Size,
              spine_array_float,
              ffi.Size,
              ffi.Size)>>('spine_mesh_attachment_compute_world_vertices_2');
  late final _spine_mesh_attachment_compute_world_vertices_2 =
      _spine_mesh_attachment_compute_world_vertices_2Ptr.asFunction<
          void Function(spine_mesh_attachment, spine_skeleton, spine_slot, int,
              int, spine_array_float, int, int)>();

  void spine_mesh_attachment_update_region(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_update_region(
      self,
    );
  }

  late final _spine_mesh_attachment_update_regionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_update_region');
  late final _spine_mesh_attachment_update_region =
      _spine_mesh_attachment_update_regionPtr
          .asFunction<void Function(spine_mesh_attachment)>();

  int spine_mesh_attachment_get_hull_length(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_hull_length(
      self,
    );
  }

  late final _spine_mesh_attachment_get_hull_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_hull_length');
  late final _spine_mesh_attachment_get_hull_length =
      _spine_mesh_attachment_get_hull_lengthPtr
          .asFunction<int Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_hull_length(
    spine_mesh_attachment self,
    int inValue,
  ) {
    return _spine_mesh_attachment_set_hull_length(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_hull_lengthPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Int)>>(
      'spine_mesh_attachment_set_hull_length');
  late final _spine_mesh_attachment_set_hull_length =
      _spine_mesh_attachment_set_hull_lengthPtr
          .asFunction<void Function(spine_mesh_attachment, int)>();

  spine_array_float spine_mesh_attachment_get_region_u_vs(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_region_u_vs(
      self,
    );
  }

  late final _spine_mesh_attachment_get_region_u_vsPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_mesh_attachment)>>(
      'spine_mesh_attachment_get_region_u_vs');
  late final _spine_mesh_attachment_get_region_u_vs =
      _spine_mesh_attachment_get_region_u_vsPtr
          .asFunction<spine_array_float Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_region_u_vs(
    spine_mesh_attachment self,
    spine_array_float inValue,
  ) {
    return _spine_mesh_attachment_set_region_u_vs(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_region_u_vsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_mesh_attachment,
              spine_array_float)>>('spine_mesh_attachment_set_region_u_vs');
  late final _spine_mesh_attachment_set_region_u_vs =
      _spine_mesh_attachment_set_region_u_vsPtr.asFunction<
          void Function(spine_mesh_attachment, spine_array_float)>();

  spine_array_float spine_mesh_attachment_get_u_vs(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_u_vs(
      self,
    );
  }

  late final _spine_mesh_attachment_get_u_vsPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_mesh_attachment)>>(
      'spine_mesh_attachment_get_u_vs');
  late final _spine_mesh_attachment_get_u_vs =
      _spine_mesh_attachment_get_u_vsPtr
          .asFunction<spine_array_float Function(spine_mesh_attachment)>();

  spine_array_unsigned_short spine_mesh_attachment_get_triangles(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_triangles(
      self,
    );
  }

  late final _spine_mesh_attachment_get_trianglesPtr = _lookup<
      ffi.NativeFunction<
          spine_array_unsigned_short Function(
              spine_mesh_attachment)>>('spine_mesh_attachment_get_triangles');
  late final _spine_mesh_attachment_get_triangles =
      _spine_mesh_attachment_get_trianglesPtr.asFunction<
          spine_array_unsigned_short Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_triangles(
    spine_mesh_attachment self,
    spine_array_unsigned_short inValue,
  ) {
    return _spine_mesh_attachment_set_triangles(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_trianglesPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  spine_mesh_attachment, spine_array_unsigned_short)>>(
      'spine_mesh_attachment_set_triangles');
  late final _spine_mesh_attachment_set_triangles =
      _spine_mesh_attachment_set_trianglesPtr.asFunction<
          void Function(spine_mesh_attachment, spine_array_unsigned_short)>();

  spine_color spine_mesh_attachment_get_color(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_color(
      self,
    );
  }

  late final _spine_mesh_attachment_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_color');
  late final _spine_mesh_attachment_get_color =
      _spine_mesh_attachment_get_colorPtr
          .asFunction<spine_color Function(spine_mesh_attachment)>();

  ffi.Pointer<ffi.Char> spine_mesh_attachment_get_path(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_path(
      self,
    );
  }

  late final _spine_mesh_attachment_get_pathPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              spine_mesh_attachment)>>('spine_mesh_attachment_get_path');
  late final _spine_mesh_attachment_get_path =
      _spine_mesh_attachment_get_pathPtr
          .asFunction<ffi.Pointer<ffi.Char> Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_path(
    spine_mesh_attachment self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_mesh_attachment_set_path(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_pathPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_mesh_attachment,
              ffi.Pointer<ffi.Char>)>>('spine_mesh_attachment_set_path');
  late final _spine_mesh_attachment_set_path =
      _spine_mesh_attachment_set_pathPtr.asFunction<
          void Function(spine_mesh_attachment, ffi.Pointer<ffi.Char>)>();

  spine_texture_region spine_mesh_attachment_get_region(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_region(
      self,
    );
  }

  late final _spine_mesh_attachment_get_regionPtr = _lookup<
      ffi.NativeFunction<
          spine_texture_region Function(
              spine_mesh_attachment)>>('spine_mesh_attachment_get_region');
  late final _spine_mesh_attachment_get_region =
      _spine_mesh_attachment_get_regionPtr
          .asFunction<spine_texture_region Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_region(
    spine_mesh_attachment self,
    spine_texture_region region,
  ) {
    return _spine_mesh_attachment_set_region(
      self,
      region,
    );
  }

  late final _spine_mesh_attachment_set_regionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_mesh_attachment,
              spine_texture_region)>>('spine_mesh_attachment_set_region');
  late final _spine_mesh_attachment_set_region =
      _spine_mesh_attachment_set_regionPtr.asFunction<
          void Function(spine_mesh_attachment, spine_texture_region)>();

  spine_sequence spine_mesh_attachment_get_sequence(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_sequence(
      self,
    );
  }

  late final _spine_mesh_attachment_get_sequencePtr = _lookup<
          ffi.NativeFunction<spine_sequence Function(spine_mesh_attachment)>>(
      'spine_mesh_attachment_get_sequence');
  late final _spine_mesh_attachment_get_sequence =
      _spine_mesh_attachment_get_sequencePtr
          .asFunction<spine_sequence Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_sequence(
    spine_mesh_attachment self,
    spine_sequence sequence,
  ) {
    return _spine_mesh_attachment_set_sequence(
      self,
      sequence,
    );
  }

  late final _spine_mesh_attachment_set_sequencePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_mesh_attachment,
              spine_sequence)>>('spine_mesh_attachment_set_sequence');
  late final _spine_mesh_attachment_set_sequence =
      _spine_mesh_attachment_set_sequencePtr
          .asFunction<void Function(spine_mesh_attachment, spine_sequence)>();

  spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_parent_mesh(
      self,
    );
  }

  late final _spine_mesh_attachment_get_parent_meshPtr = _lookup<
      ffi.NativeFunction<
          spine_mesh_attachment Function(
              spine_mesh_attachment)>>('spine_mesh_attachment_get_parent_mesh');
  late final _spine_mesh_attachment_get_parent_mesh =
      _spine_mesh_attachment_get_parent_meshPtr
          .asFunction<spine_mesh_attachment Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_parent_mesh(
    spine_mesh_attachment self,
    spine_mesh_attachment inValue,
  ) {
    return _spine_mesh_attachment_set_parent_mesh(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_parent_meshPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_mesh_attachment,
              spine_mesh_attachment)>>('spine_mesh_attachment_set_parent_mesh');
  late final _spine_mesh_attachment_set_parent_mesh =
      _spine_mesh_attachment_set_parent_meshPtr.asFunction<
          void Function(spine_mesh_attachment, spine_mesh_attachment)>();

  spine_array_unsigned_short spine_mesh_attachment_get_edges(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_edges(
      self,
    );
  }

  late final _spine_mesh_attachment_get_edgesPtr = _lookup<
      ffi.NativeFunction<
          spine_array_unsigned_short Function(
              spine_mesh_attachment)>>('spine_mesh_attachment_get_edges');
  late final _spine_mesh_attachment_get_edges =
      _spine_mesh_attachment_get_edgesPtr.asFunction<
          spine_array_unsigned_short Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_edges(
    spine_mesh_attachment self,
    spine_array_unsigned_short inValue,
  ) {
    return _spine_mesh_attachment_set_edges(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_edgesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_mesh_attachment,
              spine_array_unsigned_short)>>('spine_mesh_attachment_set_edges');
  late final _spine_mesh_attachment_set_edges =
      _spine_mesh_attachment_set_edgesPtr.asFunction<
          void Function(spine_mesh_attachment, spine_array_unsigned_short)>();

  double spine_mesh_attachment_get_width(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_width(
      self,
    );
  }

  late final _spine_mesh_attachment_get_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_width');
  late final _spine_mesh_attachment_get_width =
      _spine_mesh_attachment_get_widthPtr
          .asFunction<double Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_width(
    spine_mesh_attachment self,
    double inValue,
  ) {
    return _spine_mesh_attachment_set_width(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_widthPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Float)>>(
      'spine_mesh_attachment_set_width');
  late final _spine_mesh_attachment_set_width =
      _spine_mesh_attachment_set_widthPtr
          .asFunction<void Function(spine_mesh_attachment, double)>();

  double spine_mesh_attachment_get_height(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_height(
      self,
    );
  }

  late final _spine_mesh_attachment_get_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_height');
  late final _spine_mesh_attachment_get_height =
      _spine_mesh_attachment_get_heightPtr
          .asFunction<double Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_height(
    spine_mesh_attachment self,
    double inValue,
  ) {
    return _spine_mesh_attachment_set_height(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_heightPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Float)>>(
      'spine_mesh_attachment_set_height');
  late final _spine_mesh_attachment_set_height =
      _spine_mesh_attachment_set_heightPtr
          .asFunction<void Function(spine_mesh_attachment, double)>();

  spine_attachment spine_mesh_attachment_copy(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_copy(
      self,
    );
  }

  late final _spine_mesh_attachment_copyPtr = _lookup<
          ffi.NativeFunction<spine_attachment Function(spine_mesh_attachment)>>(
      'spine_mesh_attachment_copy');
  late final _spine_mesh_attachment_copy = _spine_mesh_attachment_copyPtr
      .asFunction<spine_attachment Function(spine_mesh_attachment)>();

  spine_mesh_attachment spine_mesh_attachment_new_linked_mesh(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_new_linked_mesh(
      self,
    );
  }

  late final _spine_mesh_attachment_new_linked_meshPtr = _lookup<
      ffi.NativeFunction<
          spine_mesh_attachment Function(
              spine_mesh_attachment)>>('spine_mesh_attachment_new_linked_mesh');
  late final _spine_mesh_attachment_new_linked_mesh =
      _spine_mesh_attachment_new_linked_meshPtr
          .asFunction<spine_mesh_attachment Function(spine_mesh_attachment)>();

  int spine_mesh_attachment_get_id(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_id(
      self,
    );
  }

  late final _spine_mesh_attachment_get_idPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_id');
  late final _spine_mesh_attachment_get_id = _spine_mesh_attachment_get_idPtr
      .asFunction<int Function(spine_mesh_attachment)>();

  spine_array_int spine_mesh_attachment_get_bones(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_bones(
      self,
    );
  }

  late final _spine_mesh_attachment_get_bonesPtr = _lookup<
          ffi.NativeFunction<spine_array_int Function(spine_mesh_attachment)>>(
      'spine_mesh_attachment_get_bones');
  late final _spine_mesh_attachment_get_bones =
      _spine_mesh_attachment_get_bonesPtr
          .asFunction<spine_array_int Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_bones(
    spine_mesh_attachment self,
    spine_array_int bones,
  ) {
    return _spine_mesh_attachment_set_bones(
      self,
      bones,
    );
  }

  late final _spine_mesh_attachment_set_bonesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_mesh_attachment,
              spine_array_int)>>('spine_mesh_attachment_set_bones');
  late final _spine_mesh_attachment_set_bones =
      _spine_mesh_attachment_set_bonesPtr
          .asFunction<void Function(spine_mesh_attachment, spine_array_int)>();

  spine_array_float spine_mesh_attachment_get_vertices(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_vertices(
      self,
    );
  }

  late final _spine_mesh_attachment_get_verticesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_mesh_attachment)>>(
      'spine_mesh_attachment_get_vertices');
  late final _spine_mesh_attachment_get_vertices =
      _spine_mesh_attachment_get_verticesPtr
          .asFunction<spine_array_float Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_vertices(
    spine_mesh_attachment self,
    spine_array_float vertices,
  ) {
    return _spine_mesh_attachment_set_vertices(
      self,
      vertices,
    );
  }

  late final _spine_mesh_attachment_set_verticesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_mesh_attachment,
              spine_array_float)>>('spine_mesh_attachment_set_vertices');
  late final _spine_mesh_attachment_set_vertices =
      _spine_mesh_attachment_set_verticesPtr.asFunction<
          void Function(spine_mesh_attachment, spine_array_float)>();

  int spine_mesh_attachment_get_world_vertices_length(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_world_vertices_length(
      self,
    );
  }

  late final _spine_mesh_attachment_get_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_world_vertices_length');
  late final _spine_mesh_attachment_get_world_vertices_length =
      _spine_mesh_attachment_get_world_vertices_lengthPtr
          .asFunction<int Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_world_vertices_length(
    spine_mesh_attachment self,
    int inValue,
  ) {
    return _spine_mesh_attachment_set_world_vertices_length(
      self,
      inValue,
    );
  }

  late final _spine_mesh_attachment_set_world_vertices_lengthPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Size)>>(
      'spine_mesh_attachment_set_world_vertices_length');
  late final _spine_mesh_attachment_set_world_vertices_length =
      _spine_mesh_attachment_set_world_vertices_lengthPtr
          .asFunction<void Function(spine_mesh_attachment, int)>();

  spine_attachment spine_mesh_attachment_get_timeline_attachment(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_timeline_attachment(
      self,
    );
  }

  late final _spine_mesh_attachment_get_timeline_attachmentPtr = _lookup<
          ffi.NativeFunction<spine_attachment Function(spine_mesh_attachment)>>(
      'spine_mesh_attachment_get_timeline_attachment');
  late final _spine_mesh_attachment_get_timeline_attachment =
      _spine_mesh_attachment_get_timeline_attachmentPtr
          .asFunction<spine_attachment Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_set_timeline_attachment(
    spine_mesh_attachment self,
    spine_attachment attachment,
  ) {
    return _spine_mesh_attachment_set_timeline_attachment(
      self,
      attachment,
    );
  }

  late final _spine_mesh_attachment_set_timeline_attachmentPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_mesh_attachment, spine_attachment)>>(
      'spine_mesh_attachment_set_timeline_attachment');
  late final _spine_mesh_attachment_set_timeline_attachment =
      _spine_mesh_attachment_set_timeline_attachmentPtr
          .asFunction<void Function(spine_mesh_attachment, spine_attachment)>();

  void spine_mesh_attachment_copy_to(
    spine_mesh_attachment self,
    spine_vertex_attachment other,
  ) {
    return _spine_mesh_attachment_copy_to(
      self,
      other,
    );
  }

  late final _spine_mesh_attachment_copy_toPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_mesh_attachment,
              spine_vertex_attachment)>>('spine_mesh_attachment_copy_to');
  late final _spine_mesh_attachment_copy_to =
      _spine_mesh_attachment_copy_toPtr.asFunction<
          void Function(spine_mesh_attachment, spine_vertex_attachment)>();

  ffi.Pointer<ffi.Char> spine_mesh_attachment_get_name(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_name(
      self,
    );
  }

  late final _spine_mesh_attachment_get_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              spine_mesh_attachment)>>('spine_mesh_attachment_get_name');
  late final _spine_mesh_attachment_get_name =
      _spine_mesh_attachment_get_namePtr
          .asFunction<ffi.Pointer<ffi.Char> Function(spine_mesh_attachment)>();

  int spine_mesh_attachment_get_ref_count(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_mesh_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_get_ref_count');
  late final _spine_mesh_attachment_get_ref_count =
      _spine_mesh_attachment_get_ref_countPtr
          .asFunction<int Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_reference(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_reference(
      self,
    );
  }

  late final _spine_mesh_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_reference');
  late final _spine_mesh_attachment_reference =
      _spine_mesh_attachment_referencePtr
          .asFunction<void Function(spine_mesh_attachment)>();

  void spine_mesh_attachment_dereference(
    spine_mesh_attachment self,
  ) {
    return _spine_mesh_attachment_dereference(
      self,
    );
  }

  late final _spine_mesh_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment)>>(
          'spine_mesh_attachment_dereference');
  late final _spine_mesh_attachment_dereference =
      _spine_mesh_attachment_dereferencePtr
          .asFunction<void Function(spine_mesh_attachment)>();

  spine_rtti spine_mesh_attachment_rtti() {
    return _spine_mesh_attachment_rtti();
  }

  late final _spine_mesh_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_mesh_attachment_rtti');
  late final _spine_mesh_attachment_rtti =
      _spine_mesh_attachment_rttiPtr.asFunction<spine_rtti Function()>();

  spine_path_attachment spine_path_attachment_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_path_attachment_create(
      name,
    );
  }

  late final _spine_path_attachment_createPtr = _lookup<
      ffi.NativeFunction<
          spine_path_attachment Function(
              ffi.Pointer<ffi.Char>)>>('spine_path_attachment_create');
  late final _spine_path_attachment_create = _spine_path_attachment_createPtr
      .asFunction<spine_path_attachment Function(ffi.Pointer<ffi.Char>)>();

  void spine_path_attachment_dispose(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_dispose(
      self,
    );
  }

  late final _spine_path_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment)>>(
          'spine_path_attachment_dispose');
  late final _spine_path_attachment_dispose = _spine_path_attachment_disposePtr
      .asFunction<void Function(spine_path_attachment)>();

  spine_rtti spine_path_attachment_get_rtti(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_rtti(
      self,
    );
  }

  late final _spine_path_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_path_attachment)>>(
          'spine_path_attachment_get_rtti');
  late final _spine_path_attachment_get_rtti =
      _spine_path_attachment_get_rttiPtr
          .asFunction<spine_rtti Function(spine_path_attachment)>();

  spine_array_float spine_path_attachment_get_lengths(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_lengths(
      self,
    );
  }

  late final _spine_path_attachment_get_lengthsPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_path_attachment)>>(
      'spine_path_attachment_get_lengths');
  late final _spine_path_attachment_get_lengths =
      _spine_path_attachment_get_lengthsPtr
          .asFunction<spine_array_float Function(spine_path_attachment)>();

  void spine_path_attachment_set_lengths(
    spine_path_attachment self,
    spine_array_float inValue,
  ) {
    return _spine_path_attachment_set_lengths(
      self,
      inValue,
    );
  }

  late final _spine_path_attachment_set_lengthsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_attachment,
              spine_array_float)>>('spine_path_attachment_set_lengths');
  late final _spine_path_attachment_set_lengths =
      _spine_path_attachment_set_lengthsPtr.asFunction<
          void Function(spine_path_attachment, spine_array_float)>();

  bool spine_path_attachment_get_closed(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_closed(
      self,
    );
  }

  late final _spine_path_attachment_get_closedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_attachment)>>(
          'spine_path_attachment_get_closed');
  late final _spine_path_attachment_get_closed =
      _spine_path_attachment_get_closedPtr
          .asFunction<bool Function(spine_path_attachment)>();

  void spine_path_attachment_set_closed(
    spine_path_attachment self,
    bool inValue,
  ) {
    return _spine_path_attachment_set_closed(
      self,
      inValue,
    );
  }

  late final _spine_path_attachment_set_closedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_path_attachment, ffi.Bool)>>(
      'spine_path_attachment_set_closed');
  late final _spine_path_attachment_set_closed =
      _spine_path_attachment_set_closedPtr
          .asFunction<void Function(spine_path_attachment, bool)>();

  bool spine_path_attachment_get_constant_speed(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_constant_speed(
      self,
    );
  }

  late final _spine_path_attachment_get_constant_speedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_attachment)>>(
          'spine_path_attachment_get_constant_speed');
  late final _spine_path_attachment_get_constant_speed =
      _spine_path_attachment_get_constant_speedPtr
          .asFunction<bool Function(spine_path_attachment)>();

  void spine_path_attachment_set_constant_speed(
    spine_path_attachment self,
    bool inValue,
  ) {
    return _spine_path_attachment_set_constant_speed(
      self,
      inValue,
    );
  }

  late final _spine_path_attachment_set_constant_speedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_path_attachment, ffi.Bool)>>(
      'spine_path_attachment_set_constant_speed');
  late final _spine_path_attachment_set_constant_speed =
      _spine_path_attachment_set_constant_speedPtr
          .asFunction<void Function(spine_path_attachment, bool)>();

  spine_color spine_path_attachment_get_color(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_color(
      self,
    );
  }

  late final _spine_path_attachment_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_path_attachment)>>(
          'spine_path_attachment_get_color');
  late final _spine_path_attachment_get_color =
      _spine_path_attachment_get_colorPtr
          .asFunction<spine_color Function(spine_path_attachment)>();

  spine_attachment spine_path_attachment_copy(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_copy(
      self,
    );
  }

  late final _spine_path_attachment_copyPtr = _lookup<
          ffi.NativeFunction<spine_attachment Function(spine_path_attachment)>>(
      'spine_path_attachment_copy');
  late final _spine_path_attachment_copy = _spine_path_attachment_copyPtr
      .asFunction<spine_attachment Function(spine_path_attachment)>();

  void spine_path_attachment_compute_world_vertices_1(
    spine_path_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    ffi.Pointer<ffi.Float> worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_path_attachment_compute_world_vertices_1(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_path_attachment_compute_world_vertices_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_attachment,
              spine_skeleton,
              spine_slot,
              ffi.Size,
              ffi.Size,
              ffi.Pointer<ffi.Float>,
              ffi.Size,
              ffi.Size)>>('spine_path_attachment_compute_world_vertices_1');
  late final _spine_path_attachment_compute_world_vertices_1 =
      _spine_path_attachment_compute_world_vertices_1Ptr.asFunction<
          void Function(spine_path_attachment, spine_skeleton, spine_slot, int,
              int, ffi.Pointer<ffi.Float>, int, int)>();

  void spine_path_attachment_compute_world_vertices_2(
    spine_path_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    spine_array_float worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_path_attachment_compute_world_vertices_2(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_path_attachment_compute_world_vertices_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_attachment,
              spine_skeleton,
              spine_slot,
              ffi.Size,
              ffi.Size,
              spine_array_float,
              ffi.Size,
              ffi.Size)>>('spine_path_attachment_compute_world_vertices_2');
  late final _spine_path_attachment_compute_world_vertices_2 =
      _spine_path_attachment_compute_world_vertices_2Ptr.asFunction<
          void Function(spine_path_attachment, spine_skeleton, spine_slot, int,
              int, spine_array_float, int, int)>();

  int spine_path_attachment_get_id(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_id(
      self,
    );
  }

  late final _spine_path_attachment_get_idPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_path_attachment)>>(
          'spine_path_attachment_get_id');
  late final _spine_path_attachment_get_id = _spine_path_attachment_get_idPtr
      .asFunction<int Function(spine_path_attachment)>();

  spine_array_int spine_path_attachment_get_bones(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_bones(
      self,
    );
  }

  late final _spine_path_attachment_get_bonesPtr = _lookup<
          ffi.NativeFunction<spine_array_int Function(spine_path_attachment)>>(
      'spine_path_attachment_get_bones');
  late final _spine_path_attachment_get_bones =
      _spine_path_attachment_get_bonesPtr
          .asFunction<spine_array_int Function(spine_path_attachment)>();

  void spine_path_attachment_set_bones(
    spine_path_attachment self,
    spine_array_int bones,
  ) {
    return _spine_path_attachment_set_bones(
      self,
      bones,
    );
  }

  late final _spine_path_attachment_set_bonesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_attachment,
              spine_array_int)>>('spine_path_attachment_set_bones');
  late final _spine_path_attachment_set_bones =
      _spine_path_attachment_set_bonesPtr
          .asFunction<void Function(spine_path_attachment, spine_array_int)>();

  spine_array_float spine_path_attachment_get_vertices(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_vertices(
      self,
    );
  }

  late final _spine_path_attachment_get_verticesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_path_attachment)>>(
      'spine_path_attachment_get_vertices');
  late final _spine_path_attachment_get_vertices =
      _spine_path_attachment_get_verticesPtr
          .asFunction<spine_array_float Function(spine_path_attachment)>();

  void spine_path_attachment_set_vertices(
    spine_path_attachment self,
    spine_array_float vertices,
  ) {
    return _spine_path_attachment_set_vertices(
      self,
      vertices,
    );
  }

  late final _spine_path_attachment_set_verticesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_attachment,
              spine_array_float)>>('spine_path_attachment_set_vertices');
  late final _spine_path_attachment_set_vertices =
      _spine_path_attachment_set_verticesPtr.asFunction<
          void Function(spine_path_attachment, spine_array_float)>();

  int spine_path_attachment_get_world_vertices_length(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_world_vertices_length(
      self,
    );
  }

  late final _spine_path_attachment_get_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_path_attachment)>>(
          'spine_path_attachment_get_world_vertices_length');
  late final _spine_path_attachment_get_world_vertices_length =
      _spine_path_attachment_get_world_vertices_lengthPtr
          .asFunction<int Function(spine_path_attachment)>();

  void spine_path_attachment_set_world_vertices_length(
    spine_path_attachment self,
    int inValue,
  ) {
    return _spine_path_attachment_set_world_vertices_length(
      self,
      inValue,
    );
  }

  late final _spine_path_attachment_set_world_vertices_lengthPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_path_attachment, ffi.Size)>>(
      'spine_path_attachment_set_world_vertices_length');
  late final _spine_path_attachment_set_world_vertices_length =
      _spine_path_attachment_set_world_vertices_lengthPtr
          .asFunction<void Function(spine_path_attachment, int)>();

  spine_attachment spine_path_attachment_get_timeline_attachment(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_timeline_attachment(
      self,
    );
  }

  late final _spine_path_attachment_get_timeline_attachmentPtr = _lookup<
          ffi.NativeFunction<spine_attachment Function(spine_path_attachment)>>(
      'spine_path_attachment_get_timeline_attachment');
  late final _spine_path_attachment_get_timeline_attachment =
      _spine_path_attachment_get_timeline_attachmentPtr
          .asFunction<spine_attachment Function(spine_path_attachment)>();

  void spine_path_attachment_set_timeline_attachment(
    spine_path_attachment self,
    spine_attachment attachment,
  ) {
    return _spine_path_attachment_set_timeline_attachment(
      self,
      attachment,
    );
  }

  late final _spine_path_attachment_set_timeline_attachmentPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_path_attachment, spine_attachment)>>(
      'spine_path_attachment_set_timeline_attachment');
  late final _spine_path_attachment_set_timeline_attachment =
      _spine_path_attachment_set_timeline_attachmentPtr
          .asFunction<void Function(spine_path_attachment, spine_attachment)>();

  void spine_path_attachment_copy_to(
    spine_path_attachment self,
    spine_vertex_attachment other,
  ) {
    return _spine_path_attachment_copy_to(
      self,
      other,
    );
  }

  late final _spine_path_attachment_copy_toPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_attachment,
              spine_vertex_attachment)>>('spine_path_attachment_copy_to');
  late final _spine_path_attachment_copy_to =
      _spine_path_attachment_copy_toPtr.asFunction<
          void Function(spine_path_attachment, spine_vertex_attachment)>();

  ffi.Pointer<ffi.Char> spine_path_attachment_get_name(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_name(
      self,
    );
  }

  late final _spine_path_attachment_get_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              spine_path_attachment)>>('spine_path_attachment_get_name');
  late final _spine_path_attachment_get_name =
      _spine_path_attachment_get_namePtr
          .asFunction<ffi.Pointer<ffi.Char> Function(spine_path_attachment)>();

  int spine_path_attachment_get_ref_count(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_path_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_path_attachment)>>(
          'spine_path_attachment_get_ref_count');
  late final _spine_path_attachment_get_ref_count =
      _spine_path_attachment_get_ref_countPtr
          .asFunction<int Function(spine_path_attachment)>();

  void spine_path_attachment_reference(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_reference(
      self,
    );
  }

  late final _spine_path_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment)>>(
          'spine_path_attachment_reference');
  late final _spine_path_attachment_reference =
      _spine_path_attachment_referencePtr
          .asFunction<void Function(spine_path_attachment)>();

  void spine_path_attachment_dereference(
    spine_path_attachment self,
  ) {
    return _spine_path_attachment_dereference(
      self,
    );
  }

  late final _spine_path_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment)>>(
          'spine_path_attachment_dereference');
  late final _spine_path_attachment_dereference =
      _spine_path_attachment_dereferencePtr
          .asFunction<void Function(spine_path_attachment)>();

  spine_rtti spine_path_attachment_rtti() {
    return _spine_path_attachment_rtti();
  }

  late final _spine_path_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_path_attachment_rtti');
  late final _spine_path_attachment_rtti =
      _spine_path_attachment_rttiPtr.asFunction<spine_rtti Function()>();

  spine_path_constraint spine_path_constraint_create(
    spine_path_constraint_data data,
    spine_skeleton skeleton,
  ) {
    return _spine_path_constraint_create(
      data,
      skeleton,
    );
  }

  late final _spine_path_constraint_createPtr = _lookup<
      ffi.NativeFunction<
          spine_path_constraint Function(spine_path_constraint_data,
              spine_skeleton)>>('spine_path_constraint_create');
  late final _spine_path_constraint_create =
      _spine_path_constraint_createPtr.asFunction<
          spine_path_constraint Function(
              spine_path_constraint_data, spine_skeleton)>();

  void spine_path_constraint_dispose(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_dispose(
      self,
    );
  }

  late final _spine_path_constraint_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint)>>(
          'spine_path_constraint_dispose');
  late final _spine_path_constraint_dispose = _spine_path_constraint_disposePtr
      .asFunction<void Function(spine_path_constraint)>();

  spine_rtti spine_path_constraint_get_rtti(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_get_rtti(
      self,
    );
  }

  late final _spine_path_constraint_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_path_constraint)>>(
          'spine_path_constraint_get_rtti');
  late final _spine_path_constraint_get_rtti =
      _spine_path_constraint_get_rttiPtr
          .asFunction<spine_rtti Function(spine_path_constraint)>();

  spine_path_constraint spine_path_constraint_copy(
    spine_path_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_path_constraint_copy(
      self,
      skeleton,
    );
  }

  late final _spine_path_constraint_copyPtr = _lookup<
      ffi.NativeFunction<
          spine_path_constraint Function(spine_path_constraint,
              spine_skeleton)>>('spine_path_constraint_copy');
  late final _spine_path_constraint_copy =
      _spine_path_constraint_copyPtr.asFunction<
          spine_path_constraint Function(
              spine_path_constraint, spine_skeleton)>();

  void spine_path_constraint_update(
    spine_path_constraint self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_path_constraint_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_path_constraint_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint, spine_skeleton,
              ffi.Int32)>>('spine_path_constraint_update');
  late final _spine_path_constraint_update = _spine_path_constraint_updatePtr
      .asFunction<void Function(spine_path_constraint, spine_skeleton, int)>();

  void spine_path_constraint_sort(
    spine_path_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_path_constraint_sort(
      self,
      skeleton,
    );
  }

  late final _spine_path_constraint_sortPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint,
              spine_skeleton)>>('spine_path_constraint_sort');
  late final _spine_path_constraint_sort = _spine_path_constraint_sortPtr
      .asFunction<void Function(spine_path_constraint, spine_skeleton)>();

  bool spine_path_constraint_is_source_active(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_is_source_active(
      self,
    );
  }

  late final _spine_path_constraint_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_constraint)>>(
          'spine_path_constraint_is_source_active');
  late final _spine_path_constraint_is_source_active =
      _spine_path_constraint_is_source_activePtr
          .asFunction<bool Function(spine_path_constraint)>();

  spine_array_bone_pose spine_path_constraint_get_bones(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_get_bones(
      self,
    );
  }

  late final _spine_path_constraint_get_bonesPtr = _lookup<
      ffi.NativeFunction<
          spine_array_bone_pose Function(
              spine_path_constraint)>>('spine_path_constraint_get_bones');
  late final _spine_path_constraint_get_bones =
      _spine_path_constraint_get_bonesPtr
          .asFunction<spine_array_bone_pose Function(spine_path_constraint)>();

  spine_slot spine_path_constraint_get_slot(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_get_slot(
      self,
    );
  }

  late final _spine_path_constraint_get_slotPtr =
      _lookup<ffi.NativeFunction<spine_slot Function(spine_path_constraint)>>(
          'spine_path_constraint_get_slot');
  late final _spine_path_constraint_get_slot =
      _spine_path_constraint_get_slotPtr
          .asFunction<spine_slot Function(spine_path_constraint)>();

  void spine_path_constraint_set_slot(
    spine_path_constraint self,
    spine_slot slot,
  ) {
    return _spine_path_constraint_set_slot(
      self,
      slot,
    );
  }

  late final _spine_path_constraint_set_slotPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint,
              spine_slot)>>('spine_path_constraint_set_slot');
  late final _spine_path_constraint_set_slot =
      _spine_path_constraint_set_slotPtr
          .asFunction<void Function(spine_path_constraint, spine_slot)>();

  spine_path_constraint_data spine_path_constraint_get_data(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_get_data(
      self,
    );
  }

  late final _spine_path_constraint_get_dataPtr = _lookup<
      ffi.NativeFunction<
          spine_path_constraint_data Function(
              spine_path_constraint)>>('spine_path_constraint_get_data');
  late final _spine_path_constraint_get_data =
      _spine_path_constraint_get_dataPtr.asFunction<
          spine_path_constraint_data Function(spine_path_constraint)>();

  spine_path_constraint_pose spine_path_constraint_get_pose(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_get_pose(
      self,
    );
  }

  late final _spine_path_constraint_get_posePtr = _lookup<
      ffi.NativeFunction<
          spine_path_constraint_pose Function(
              spine_path_constraint)>>('spine_path_constraint_get_pose');
  late final _spine_path_constraint_get_pose =
      _spine_path_constraint_get_posePtr.asFunction<
          spine_path_constraint_pose Function(spine_path_constraint)>();

  spine_path_constraint_pose spine_path_constraint_get_applied_pose(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_get_applied_pose(
      self,
    );
  }

  late final _spine_path_constraint_get_applied_posePtr = _lookup<
          ffi.NativeFunction<
              spine_path_constraint_pose Function(spine_path_constraint)>>(
      'spine_path_constraint_get_applied_pose');
  late final _spine_path_constraint_get_applied_pose =
      _spine_path_constraint_get_applied_posePtr.asFunction<
          spine_path_constraint_pose Function(spine_path_constraint)>();

  void spine_path_constraint_reset_constrained(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_reset_constrained(
      self,
    );
  }

  late final _spine_path_constraint_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint)>>(
          'spine_path_constraint_reset_constrained');
  late final _spine_path_constraint_reset_constrained =
      _spine_path_constraint_reset_constrainedPtr
          .asFunction<void Function(spine_path_constraint)>();

  void spine_path_constraint_constrained(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_constrained(
      self,
    );
  }

  late final _spine_path_constraint_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint)>>(
          'spine_path_constraint_constrained');
  late final _spine_path_constraint_constrained =
      _spine_path_constraint_constrainedPtr
          .asFunction<void Function(spine_path_constraint)>();

  bool spine_path_constraint_is_pose_equal_to_applied(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_path_constraint_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_constraint)>>(
          'spine_path_constraint_is_pose_equal_to_applied');
  late final _spine_path_constraint_is_pose_equal_to_applied =
      _spine_path_constraint_is_pose_equal_to_appliedPtr
          .asFunction<bool Function(spine_path_constraint)>();

  bool spine_path_constraint_is_active(
    spine_path_constraint self,
  ) {
    return _spine_path_constraint_is_active(
      self,
    );
  }

  late final _spine_path_constraint_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_path_constraint)>>(
          'spine_path_constraint_is_active');
  late final _spine_path_constraint_is_active =
      _spine_path_constraint_is_activePtr
          .asFunction<bool Function(spine_path_constraint)>();

  void spine_path_constraint_set_active(
    spine_path_constraint self,
    bool active,
  ) {
    return _spine_path_constraint_set_active(
      self,
      active,
    );
  }

  late final _spine_path_constraint_set_activePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_path_constraint, ffi.Bool)>>(
      'spine_path_constraint_set_active');
  late final _spine_path_constraint_set_active =
      _spine_path_constraint_set_activePtr
          .asFunction<void Function(spine_path_constraint, bool)>();

  spine_rtti spine_path_constraint_rtti() {
    return _spine_path_constraint_rtti();
  }

  late final _spine_path_constraint_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_path_constraint_rtti');
  late final _spine_path_constraint_rtti =
      _spine_path_constraint_rttiPtr.asFunction<spine_rtti Function()>();

  spine_path_constraint_data spine_path_constraint_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_path_constraint_data_create(
      name,
    );
  }

  late final _spine_path_constraint_data_createPtr = _lookup<
      ffi.NativeFunction<
          spine_path_constraint_data Function(
              ffi.Pointer<ffi.Char>)>>('spine_path_constraint_data_create');
  late final _spine_path_constraint_data_create =
      _spine_path_constraint_data_createPtr.asFunction<
          spine_path_constraint_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_path_constraint_data_dispose(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_dispose(
      self,
    );
  }

  late final _spine_path_constraint_data_disposePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data)>>(
      'spine_path_constraint_data_dispose');
  late final _spine_path_constraint_data_dispose =
      _spine_path_constraint_data_disposePtr
          .asFunction<void Function(spine_path_constraint_data)>();

  spine_rtti spine_path_constraint_data_get_rtti(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_rtti(
      self,
    );
  }

  late final _spine_path_constraint_data_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_path_constraint_data)>>(
      'spine_path_constraint_data_get_rtti');
  late final _spine_path_constraint_data_get_rtti =
      _spine_path_constraint_data_get_rttiPtr
          .asFunction<spine_rtti Function(spine_path_constraint_data)>();

  spine_constraint spine_path_constraint_data_create_method(
    spine_path_constraint_data self,
    spine_skeleton skeleton,
  ) {
    return _spine_path_constraint_data_create_method(
      self,
      skeleton,
    );
  }

  late final _spine_path_constraint_data_create_methodPtr = _lookup<
      ffi.NativeFunction<
          spine_constraint Function(spine_path_constraint_data,
              spine_skeleton)>>('spine_path_constraint_data_create_method');
  late final _spine_path_constraint_data_create_method =
      _spine_path_constraint_data_create_methodPtr.asFunction<
          spine_constraint Function(
              spine_path_constraint_data, spine_skeleton)>();

  spine_array_bone_data spine_path_constraint_data_get_bones(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_bones(
      self,
    );
  }

  late final _spine_path_constraint_data_get_bonesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_bone_data Function(spine_path_constraint_data)>>(
      'spine_path_constraint_data_get_bones');
  late final _spine_path_constraint_data_get_bones =
      _spine_path_constraint_data_get_bonesPtr.asFunction<
          spine_array_bone_data Function(spine_path_constraint_data)>();

  spine_slot_data spine_path_constraint_data_get_slot(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_slot(
      self,
    );
  }

  late final _spine_path_constraint_data_get_slotPtr = _lookup<
          ffi.NativeFunction<
              spine_slot_data Function(spine_path_constraint_data)>>(
      'spine_path_constraint_data_get_slot');
  late final _spine_path_constraint_data_get_slot =
      _spine_path_constraint_data_get_slotPtr
          .asFunction<spine_slot_data Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_slot(
    spine_path_constraint_data self,
    spine_slot_data slot,
  ) {
    return _spine_path_constraint_data_set_slot(
      self,
      slot,
    );
  }

  late final _spine_path_constraint_data_set_slotPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_data,
              spine_slot_data)>>('spine_path_constraint_data_set_slot');
  late final _spine_path_constraint_data_set_slot =
      _spine_path_constraint_data_set_slotPtr.asFunction<
          void Function(spine_path_constraint_data, spine_slot_data)>();

  int spine_path_constraint_data_get_position_mode(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_position_mode(
      self,
    );
  }

  late final _spine_path_constraint_data_get_position_modePtr = _lookup<
          ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint_data)>>(
      'spine_path_constraint_data_get_position_mode');
  late final _spine_path_constraint_data_get_position_mode =
      _spine_path_constraint_data_get_position_modePtr
          .asFunction<int Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_position_mode(
    spine_path_constraint_data self,
    int positionMode,
  ) {
    return _spine_path_constraint_data_set_position_mode(
      self,
      positionMode,
    );
  }

  late final _spine_path_constraint_data_set_position_modePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_data,
              ffi.Int32)>>('spine_path_constraint_data_set_position_mode');
  late final _spine_path_constraint_data_set_position_mode =
      _spine_path_constraint_data_set_position_modePtr
          .asFunction<void Function(spine_path_constraint_data, int)>();

  int spine_path_constraint_data_get_spacing_mode(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_spacing_mode(
      self,
    );
  }

  late final _spine_path_constraint_data_get_spacing_modePtr = _lookup<
          ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint_data)>>(
      'spine_path_constraint_data_get_spacing_mode');
  late final _spine_path_constraint_data_get_spacing_mode =
      _spine_path_constraint_data_get_spacing_modePtr
          .asFunction<int Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_spacing_mode(
    spine_path_constraint_data self,
    int spacingMode,
  ) {
    return _spine_path_constraint_data_set_spacing_mode(
      self,
      spacingMode,
    );
  }

  late final _spine_path_constraint_data_set_spacing_modePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_data,
              ffi.Int32)>>('spine_path_constraint_data_set_spacing_mode');
  late final _spine_path_constraint_data_set_spacing_mode =
      _spine_path_constraint_data_set_spacing_modePtr
          .asFunction<void Function(spine_path_constraint_data, int)>();

  int spine_path_constraint_data_get_rotate_mode(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_rotate_mode(
      self,
    );
  }

  late final _spine_path_constraint_data_get_rotate_modePtr = _lookup<
          ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint_data)>>(
      'spine_path_constraint_data_get_rotate_mode');
  late final _spine_path_constraint_data_get_rotate_mode =
      _spine_path_constraint_data_get_rotate_modePtr
          .asFunction<int Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_rotate_mode(
    spine_path_constraint_data self,
    int rotateMode,
  ) {
    return _spine_path_constraint_data_set_rotate_mode(
      self,
      rotateMode,
    );
  }

  late final _spine_path_constraint_data_set_rotate_modePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_data,
              ffi.Int32)>>('spine_path_constraint_data_set_rotate_mode');
  late final _spine_path_constraint_data_set_rotate_mode =
      _spine_path_constraint_data_set_rotate_modePtr
          .asFunction<void Function(spine_path_constraint_data, int)>();

  double spine_path_constraint_data_get_offset_rotation(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_offset_rotation(
      self,
    );
  }

  late final _spine_path_constraint_data_get_offset_rotationPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_path_constraint_data)>>(
      'spine_path_constraint_data_get_offset_rotation');
  late final _spine_path_constraint_data_get_offset_rotation =
      _spine_path_constraint_data_get_offset_rotationPtr
          .asFunction<double Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_offset_rotation(
    spine_path_constraint_data self,
    double offsetRotation,
  ) {
    return _spine_path_constraint_data_set_offset_rotation(
      self,
      offsetRotation,
    );
  }

  late final _spine_path_constraint_data_set_offset_rotationPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_data,
              ffi.Float)>>('spine_path_constraint_data_set_offset_rotation');
  late final _spine_path_constraint_data_set_offset_rotation =
      _spine_path_constraint_data_set_offset_rotationPtr
          .asFunction<void Function(spine_path_constraint_data, double)>();

  ffi.Pointer<ffi.Char> spine_path_constraint_data_get_name(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_name(
      self,
    );
  }

  late final _spine_path_constraint_data_get_namePtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(spine_path_constraint_data)>>(
      'spine_path_constraint_data_get_name');
  late final _spine_path_constraint_data_get_name =
      _spine_path_constraint_data_get_namePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(spine_path_constraint_data)>();

  bool spine_path_constraint_data_get_skin_required(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_skin_required(
      self,
    );
  }

  late final _spine_path_constraint_data_get_skin_requiredPtr = _lookup<
          ffi.NativeFunction<ffi.Bool Function(spine_path_constraint_data)>>(
      'spine_path_constraint_data_get_skin_required');
  late final _spine_path_constraint_data_get_skin_required =
      _spine_path_constraint_data_get_skin_requiredPtr
          .asFunction<bool Function(spine_path_constraint_data)>();

  spine_path_constraint_pose spine_path_constraint_data_get_setup_pose(
    spine_path_constraint_data self,
  ) {
    return _spine_path_constraint_data_get_setup_pose(
      self,
    );
  }

  late final _spine_path_constraint_data_get_setup_posePtr = _lookup<
          ffi.NativeFunction<
              spine_path_constraint_pose Function(spine_path_constraint_data)>>(
      'spine_path_constraint_data_get_setup_pose');
  late final _spine_path_constraint_data_get_setup_pose =
      _spine_path_constraint_data_get_setup_posePtr.asFunction<
          spine_path_constraint_pose Function(spine_path_constraint_data)>();

  void spine_path_constraint_data_set_skin_required(
    spine_path_constraint_data self,
    bool skinRequired,
  ) {
    return _spine_path_constraint_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_path_constraint_data_set_skin_requiredPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_data,
              ffi.Bool)>>('spine_path_constraint_data_set_skin_required');
  late final _spine_path_constraint_data_set_skin_required =
      _spine_path_constraint_data_set_skin_requiredPtr
          .asFunction<void Function(spine_path_constraint_data, bool)>();

  spine_rtti spine_path_constraint_data_rtti() {
    return _spine_path_constraint_data_rtti();
  }

  late final _spine_path_constraint_data_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_path_constraint_data_rtti');
  late final _spine_path_constraint_data_rtti =
      _spine_path_constraint_data_rttiPtr.asFunction<spine_rtti Function()>();

  spine_path_constraint_mix_timeline spine_path_constraint_mix_timeline_create(
    int frameCount,
    int bezierCount,
    int constraintIndex,
  ) {
    return _spine_path_constraint_mix_timeline_create(
      frameCount,
      bezierCount,
      constraintIndex,
    );
  }

  late final _spine_path_constraint_mix_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_path_constraint_mix_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_path_constraint_mix_timeline_create');
  late final _spine_path_constraint_mix_timeline_create =
      _spine_path_constraint_mix_timeline_createPtr.asFunction<
          spine_path_constraint_mix_timeline Function(int, int, int)>();

  void spine_path_constraint_mix_timeline_dispose(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_dispose(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_path_constraint_mix_timeline)>>(
      'spine_path_constraint_mix_timeline_dispose');
  late final _spine_path_constraint_mix_timeline_dispose =
      _spine_path_constraint_mix_timeline_disposePtr
          .asFunction<void Function(spine_path_constraint_mix_timeline)>();

  spine_rtti spine_path_constraint_mix_timeline_get_rtti(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_rtti(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_path_constraint_mix_timeline)>>(
      'spine_path_constraint_mix_timeline_get_rtti');
  late final _spine_path_constraint_mix_timeline_get_rtti =
      _spine_path_constraint_mix_timeline_get_rttiPtr.asFunction<
          spine_rtti Function(spine_path_constraint_mix_timeline)>();

  void spine_path_constraint_mix_timeline_apply(
    spine_path_constraint_mix_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_path_constraint_mix_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_path_constraint_mix_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_constraint_mix_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_path_constraint_mix_timeline_apply');
  late final _spine_path_constraint_mix_timeline_apply =
      _spine_path_constraint_mix_timeline_applyPtr.asFunction<
          void Function(spine_path_constraint_mix_timeline, spine_skeleton,
              double, double, spine_array_event, double, int, int, bool)>();

  void spine_path_constraint_mix_timeline_set_frame(
    spine_path_constraint_mix_timeline self,
    int frame,
    double time,
    double mixRotate,
    double mixX,
    double mixY,
  ) {
    return _spine_path_constraint_mix_timeline_set_frame(
      self,
      frame,
      time,
      mixRotate,
      mixX,
      mixY,
    );
  }

  late final _spine_path_constraint_mix_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_constraint_mix_timeline,
              ffi.Int,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_path_constraint_mix_timeline_set_frame');
  late final _spine_path_constraint_mix_timeline_set_frame =
      _spine_path_constraint_mix_timeline_set_framePtr.asFunction<
          void Function(spine_path_constraint_mix_timeline, int, double, double,
              double, double)>();

  void spine_path_constraint_mix_timeline_set_linear(
    spine_path_constraint_mix_timeline self,
    int frame,
  ) {
    return _spine_path_constraint_mix_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_path_constraint_mix_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_mix_timeline,
              ffi.Size)>>('spine_path_constraint_mix_timeline_set_linear');
  late final _spine_path_constraint_mix_timeline_set_linear =
      _spine_path_constraint_mix_timeline_set_linearPtr
          .asFunction<void Function(spine_path_constraint_mix_timeline, int)>();

  void spine_path_constraint_mix_timeline_set_stepped(
    spine_path_constraint_mix_timeline self,
    int frame,
  ) {
    return _spine_path_constraint_mix_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_path_constraint_mix_timeline_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_mix_timeline,
              ffi.Size)>>('spine_path_constraint_mix_timeline_set_stepped');
  late final _spine_path_constraint_mix_timeline_set_stepped =
      _spine_path_constraint_mix_timeline_set_steppedPtr
          .asFunction<void Function(spine_path_constraint_mix_timeline, int)>();

  void spine_path_constraint_mix_timeline_set_bezier(
    spine_path_constraint_mix_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_path_constraint_mix_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_path_constraint_mix_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_constraint_mix_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_path_constraint_mix_timeline_set_bezier');
  late final _spine_path_constraint_mix_timeline_set_bezier =
      _spine_path_constraint_mix_timeline_set_bezierPtr.asFunction<
          void Function(
              spine_path_constraint_mix_timeline,
              int,
              int,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double)>();

  double spine_path_constraint_mix_timeline_get_bezier_value(
    spine_path_constraint_mix_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_path_constraint_mix_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_bezier_valuePtr = _lookup<
          ffi.NativeFunction<
              ffi.Float Function(spine_path_constraint_mix_timeline, ffi.Float,
                  ffi.Size, ffi.Size, ffi.Size)>>(
      'spine_path_constraint_mix_timeline_get_bezier_value');
  late final _spine_path_constraint_mix_timeline_get_bezier_value =
      _spine_path_constraint_mix_timeline_get_bezier_valuePtr.asFunction<
          double Function(
              spine_path_constraint_mix_timeline, double, int, int, int)>();

  spine_array_float spine_path_constraint_mix_timeline_get_curves(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_curves(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_path_constraint_mix_timeline)>>(
      'spine_path_constraint_mix_timeline_get_curves');
  late final _spine_path_constraint_mix_timeline_get_curves =
      _spine_path_constraint_mix_timeline_get_curvesPtr.asFunction<
          spine_array_float Function(spine_path_constraint_mix_timeline)>();

  int spine_path_constraint_mix_timeline_get_frame_entries(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_frame_entriesPtr = _lookup<
          ffi.NativeFunction<
              ffi.Size Function(spine_path_constraint_mix_timeline)>>(
      'spine_path_constraint_mix_timeline_get_frame_entries');
  late final _spine_path_constraint_mix_timeline_get_frame_entries =
      _spine_path_constraint_mix_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_path_constraint_mix_timeline)>();

  int spine_path_constraint_mix_timeline_get_frame_count(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_frame_countPtr = _lookup<
          ffi.NativeFunction<
              ffi.Size Function(spine_path_constraint_mix_timeline)>>(
      'spine_path_constraint_mix_timeline_get_frame_count');
  late final _spine_path_constraint_mix_timeline_get_frame_count =
      _spine_path_constraint_mix_timeline_get_frame_countPtr
          .asFunction<int Function(spine_path_constraint_mix_timeline)>();

  spine_array_float spine_path_constraint_mix_timeline_get_frames(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_frames(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_path_constraint_mix_timeline)>>(
      'spine_path_constraint_mix_timeline_get_frames');
  late final _spine_path_constraint_mix_timeline_get_frames =
      _spine_path_constraint_mix_timeline_get_framesPtr.asFunction<
          spine_array_float Function(spine_path_constraint_mix_timeline)>();

  double spine_path_constraint_mix_timeline_get_duration(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_duration(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<
              ffi.Float Function(spine_path_constraint_mix_timeline)>>(
      'spine_path_constraint_mix_timeline_get_duration');
  late final _spine_path_constraint_mix_timeline_get_duration =
      _spine_path_constraint_mix_timeline_get_durationPtr
          .asFunction<double Function(spine_path_constraint_mix_timeline)>();

  spine_array_property_id spine_path_constraint_mix_timeline_get_property_ids(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(
                  spine_path_constraint_mix_timeline)>>(
      'spine_path_constraint_mix_timeline_get_property_ids');
  late final _spine_path_constraint_mix_timeline_get_property_ids =
      _spine_path_constraint_mix_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(
              spine_path_constraint_mix_timeline)>();

  int spine_path_constraint_mix_timeline_get_constraint_index(
    spine_path_constraint_mix_timeline self,
  ) {
    return _spine_path_constraint_mix_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_path_constraint_mix_timeline_get_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(spine_path_constraint_mix_timeline)>>(
          'spine_path_constraint_mix_timeline_get_constraint_index');
  late final _spine_path_constraint_mix_timeline_get_constraint_index =
      _spine_path_constraint_mix_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_path_constraint_mix_timeline)>();

  void spine_path_constraint_mix_timeline_set_constraint_index(
    spine_path_constraint_mix_timeline self,
    int inValue,
  ) {
    return _spine_path_constraint_mix_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_path_constraint_mix_timeline_set_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_path_constraint_mix_timeline, ffi.Int)>>(
          'spine_path_constraint_mix_timeline_set_constraint_index');
  late final _spine_path_constraint_mix_timeline_set_constraint_index =
      _spine_path_constraint_mix_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_path_constraint_mix_timeline, int)>();

  spine_rtti spine_path_constraint_mix_timeline_rtti() {
    return _spine_path_constraint_mix_timeline_rtti();
  }

  late final _spine_path_constraint_mix_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_path_constraint_mix_timeline_rtti');
  late final _spine_path_constraint_mix_timeline_rtti =
      _spine_path_constraint_mix_timeline_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_path_constraint_pose spine_path_constraint_pose_create() {
    return _spine_path_constraint_pose_create();
  }

  late final _spine_path_constraint_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_path_constraint_pose Function()>>(
          'spine_path_constraint_pose_create');
  late final _spine_path_constraint_pose_create =
      _spine_path_constraint_pose_createPtr
          .asFunction<spine_path_constraint_pose Function()>();

  void spine_path_constraint_pose_dispose(
    spine_path_constraint_pose self,
  ) {
    return _spine_path_constraint_pose_dispose(
      self,
    );
  }

  late final _spine_path_constraint_pose_disposePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_path_constraint_pose)>>(
      'spine_path_constraint_pose_dispose');
  late final _spine_path_constraint_pose_dispose =
      _spine_path_constraint_pose_disposePtr
          .asFunction<void Function(spine_path_constraint_pose)>();

  void spine_path_constraint_pose_set(
    spine_path_constraint_pose self,
    spine_path_constraint_pose pose,
  ) {
    return _spine_path_constraint_pose_set(
      self,
      pose,
    );
  }

  late final _spine_path_constraint_pose_setPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_pose,
              spine_path_constraint_pose)>>('spine_path_constraint_pose_set');
  late final _spine_path_constraint_pose_set =
      _spine_path_constraint_pose_setPtr.asFunction<
          void Function(
              spine_path_constraint_pose, spine_path_constraint_pose)>();

  double spine_path_constraint_pose_get_position(
    spine_path_constraint_pose self,
  ) {
    return _spine_path_constraint_pose_get_position(
      self,
    );
  }

  late final _spine_path_constraint_pose_get_positionPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_path_constraint_pose)>>(
      'spine_path_constraint_pose_get_position');
  late final _spine_path_constraint_pose_get_position =
      _spine_path_constraint_pose_get_positionPtr
          .asFunction<double Function(spine_path_constraint_pose)>();

  void spine_path_constraint_pose_set_position(
    spine_path_constraint_pose self,
    double position,
  ) {
    return _spine_path_constraint_pose_set_position(
      self,
      position,
    );
  }

  late final _spine_path_constraint_pose_set_positionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_pose,
              ffi.Float)>>('spine_path_constraint_pose_set_position');
  late final _spine_path_constraint_pose_set_position =
      _spine_path_constraint_pose_set_positionPtr
          .asFunction<void Function(spine_path_constraint_pose, double)>();

  double spine_path_constraint_pose_get_spacing(
    spine_path_constraint_pose self,
  ) {
    return _spine_path_constraint_pose_get_spacing(
      self,
    );
  }

  late final _spine_path_constraint_pose_get_spacingPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_path_constraint_pose)>>(
      'spine_path_constraint_pose_get_spacing');
  late final _spine_path_constraint_pose_get_spacing =
      _spine_path_constraint_pose_get_spacingPtr
          .asFunction<double Function(spine_path_constraint_pose)>();

  void spine_path_constraint_pose_set_spacing(
    spine_path_constraint_pose self,
    double spacing,
  ) {
    return _spine_path_constraint_pose_set_spacing(
      self,
      spacing,
    );
  }

  late final _spine_path_constraint_pose_set_spacingPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_pose,
              ffi.Float)>>('spine_path_constraint_pose_set_spacing');
  late final _spine_path_constraint_pose_set_spacing =
      _spine_path_constraint_pose_set_spacingPtr
          .asFunction<void Function(spine_path_constraint_pose, double)>();

  double spine_path_constraint_pose_get_mix_rotate(
    spine_path_constraint_pose self,
  ) {
    return _spine_path_constraint_pose_get_mix_rotate(
      self,
    );
  }

  late final _spine_path_constraint_pose_get_mix_rotatePtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_path_constraint_pose)>>(
      'spine_path_constraint_pose_get_mix_rotate');
  late final _spine_path_constraint_pose_get_mix_rotate =
      _spine_path_constraint_pose_get_mix_rotatePtr
          .asFunction<double Function(spine_path_constraint_pose)>();

  void spine_path_constraint_pose_set_mix_rotate(
    spine_path_constraint_pose self,
    double mixRotate,
  ) {
    return _spine_path_constraint_pose_set_mix_rotate(
      self,
      mixRotate,
    );
  }

  late final _spine_path_constraint_pose_set_mix_rotatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_pose,
              ffi.Float)>>('spine_path_constraint_pose_set_mix_rotate');
  late final _spine_path_constraint_pose_set_mix_rotate =
      _spine_path_constraint_pose_set_mix_rotatePtr
          .asFunction<void Function(spine_path_constraint_pose, double)>();

  double spine_path_constraint_pose_get_mix_x(
    spine_path_constraint_pose self,
  ) {
    return _spine_path_constraint_pose_get_mix_x(
      self,
    );
  }

  late final _spine_path_constraint_pose_get_mix_xPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_path_constraint_pose)>>(
      'spine_path_constraint_pose_get_mix_x');
  late final _spine_path_constraint_pose_get_mix_x =
      _spine_path_constraint_pose_get_mix_xPtr
          .asFunction<double Function(spine_path_constraint_pose)>();

  void spine_path_constraint_pose_set_mix_x(
    spine_path_constraint_pose self,
    double mixX,
  ) {
    return _spine_path_constraint_pose_set_mix_x(
      self,
      mixX,
    );
  }

  late final _spine_path_constraint_pose_set_mix_xPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_pose,
              ffi.Float)>>('spine_path_constraint_pose_set_mix_x');
  late final _spine_path_constraint_pose_set_mix_x =
      _spine_path_constraint_pose_set_mix_xPtr
          .asFunction<void Function(spine_path_constraint_pose, double)>();

  double spine_path_constraint_pose_get_mix_y(
    spine_path_constraint_pose self,
  ) {
    return _spine_path_constraint_pose_get_mix_y(
      self,
    );
  }

  late final _spine_path_constraint_pose_get_mix_yPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_path_constraint_pose)>>(
      'spine_path_constraint_pose_get_mix_y');
  late final _spine_path_constraint_pose_get_mix_y =
      _spine_path_constraint_pose_get_mix_yPtr
          .asFunction<double Function(spine_path_constraint_pose)>();

  void spine_path_constraint_pose_set_mix_y(
    spine_path_constraint_pose self,
    double mixY,
  ) {
    return _spine_path_constraint_pose_set_mix_y(
      self,
      mixY,
    );
  }

  late final _spine_path_constraint_pose_set_mix_yPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_pose,
              ffi.Float)>>('spine_path_constraint_pose_set_mix_y');
  late final _spine_path_constraint_pose_set_mix_y =
      _spine_path_constraint_pose_set_mix_yPtr
          .asFunction<void Function(spine_path_constraint_pose, double)>();

  spine_path_constraint_position_timeline
      spine_path_constraint_position_timeline_create(
    int frameCount,
    int bezierCount,
    int constraintIndex,
  ) {
    return _spine_path_constraint_position_timeline_create(
      frameCount,
      bezierCount,
      constraintIndex,
    );
  }

  late final _spine_path_constraint_position_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_path_constraint_position_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_path_constraint_position_timeline_create');
  late final _spine_path_constraint_position_timeline_create =
      _spine_path_constraint_position_timeline_createPtr.asFunction<
          spine_path_constraint_position_timeline Function(int, int, int)>();

  void spine_path_constraint_position_timeline_dispose(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_dispose(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_path_constraint_position_timeline)>>(
      'spine_path_constraint_position_timeline_dispose');
  late final _spine_path_constraint_position_timeline_dispose =
      _spine_path_constraint_position_timeline_disposePtr
          .asFunction<void Function(spine_path_constraint_position_timeline)>();

  spine_rtti spine_path_constraint_position_timeline_get_rtti(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_rtti(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_path_constraint_position_timeline)>>(
      'spine_path_constraint_position_timeline_get_rtti');
  late final _spine_path_constraint_position_timeline_get_rtti =
      _spine_path_constraint_position_timeline_get_rttiPtr.asFunction<
          spine_rtti Function(spine_path_constraint_position_timeline)>();

  void spine_path_constraint_position_timeline_apply(
    spine_path_constraint_position_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_path_constraint_position_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_path_constraint_position_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_constraint_position_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_path_constraint_position_timeline_apply');
  late final _spine_path_constraint_position_timeline_apply =
      _spine_path_constraint_position_timeline_applyPtr.asFunction<
          void Function(spine_path_constraint_position_timeline, spine_skeleton,
              double, double, spine_array_event, double, int, int, bool)>();

  void spine_path_constraint_position_timeline_set_frame(
    spine_path_constraint_position_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_path_constraint_position_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_path_constraint_position_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_constraint_position_timeline,
              ffi.Size,
              ffi.Float,
              ffi.Float)>>('spine_path_constraint_position_timeline_set_frame');
  late final _spine_path_constraint_position_timeline_set_frame =
      _spine_path_constraint_position_timeline_set_framePtr.asFunction<
          void Function(
              spine_path_constraint_position_timeline, int, double, double)>();

  double spine_path_constraint_position_timeline_get_curve_value(
    spine_path_constraint_position_timeline self,
    double time,
  ) {
    return _spine_path_constraint_position_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_path_constraint_position_timeline_get_curve_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_path_constraint_position_timeline, ffi.Float)>>(
          'spine_path_constraint_position_timeline_get_curve_value');
  late final _spine_path_constraint_position_timeline_get_curve_value =
      _spine_path_constraint_position_timeline_get_curve_valuePtr.asFunction<
          double Function(spine_path_constraint_position_timeline, double)>();

  double spine_path_constraint_position_timeline_get_relative_value(
    spine_path_constraint_position_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_path_constraint_position_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_path_constraint_position_timeline_get_relative_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_path_constraint_position_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_path_constraint_position_timeline_get_relative_value');
  late final _spine_path_constraint_position_timeline_get_relative_value =
      _spine_path_constraint_position_timeline_get_relative_valuePtr.asFunction<
          double Function(spine_path_constraint_position_timeline, double,
              double, int, double, double)>();

  double spine_path_constraint_position_timeline_get_absolute_value_1(
    spine_path_constraint_position_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_path_constraint_position_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_path_constraint_position_timeline_get_absolute_value_1Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_path_constraint_position_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_path_constraint_position_timeline_get_absolute_value_1');
  late final _spine_path_constraint_position_timeline_get_absolute_value_1 =
      _spine_path_constraint_position_timeline_get_absolute_value_1Ptr
          .asFunction<
              double Function(spine_path_constraint_position_timeline, double,
                  double, int, double, double)>();

  double spine_path_constraint_position_timeline_get_absolute_value_2(
    spine_path_constraint_position_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_path_constraint_position_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_path_constraint_position_timeline_get_absolute_value_2Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_path_constraint_position_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_path_constraint_position_timeline_get_absolute_value_2');
  late final _spine_path_constraint_position_timeline_get_absolute_value_2 =
      _spine_path_constraint_position_timeline_get_absolute_value_2Ptr
          .asFunction<
              double Function(spine_path_constraint_position_timeline, double,
                  double, int, double, double, double)>();

  double spine_path_constraint_position_timeline_get_scale_value(
    spine_path_constraint_position_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_path_constraint_position_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_path_constraint_position_timeline_get_scale_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_path_constraint_position_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_path_constraint_position_timeline_get_scale_value');
  late final _spine_path_constraint_position_timeline_get_scale_value =
      _spine_path_constraint_position_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_path_constraint_position_timeline, double,
              double, int, int, double, double)>();

  void spine_path_constraint_position_timeline_set_linear(
    spine_path_constraint_position_timeline self,
    int frame,
  ) {
    return _spine_path_constraint_position_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_path_constraint_position_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_position_timeline,
              ffi.Size)>>('spine_path_constraint_position_timeline_set_linear');
  late final _spine_path_constraint_position_timeline_set_linear =
      _spine_path_constraint_position_timeline_set_linearPtr.asFunction<
          void Function(spine_path_constraint_position_timeline, int)>();

  void spine_path_constraint_position_timeline_set_stepped(
    spine_path_constraint_position_timeline self,
    int frame,
  ) {
    return _spine_path_constraint_position_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_path_constraint_position_timeline_set_steppedPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  spine_path_constraint_position_timeline, ffi.Size)>>(
      'spine_path_constraint_position_timeline_set_stepped');
  late final _spine_path_constraint_position_timeline_set_stepped =
      _spine_path_constraint_position_timeline_set_steppedPtr.asFunction<
          void Function(spine_path_constraint_position_timeline, int)>();

  void spine_path_constraint_position_timeline_set_bezier(
    spine_path_constraint_position_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_path_constraint_position_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_path_constraint_position_timeline_set_bezierPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  spine_path_constraint_position_timeline,
                  ffi.Size,
                  ffi.Size,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float)>>(
      'spine_path_constraint_position_timeline_set_bezier');
  late final _spine_path_constraint_position_timeline_set_bezier =
      _spine_path_constraint_position_timeline_set_bezierPtr.asFunction<
          void Function(
              spine_path_constraint_position_timeline,
              int,
              int,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double)>();

  double spine_path_constraint_position_timeline_get_bezier_value(
    spine_path_constraint_position_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_path_constraint_position_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_path_constraint_position_timeline_get_bezier_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_path_constraint_position_timeline,
                      ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_path_constraint_position_timeline_get_bezier_value');
  late final _spine_path_constraint_position_timeline_get_bezier_value =
      _spine_path_constraint_position_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_path_constraint_position_timeline, double, int,
              int, int)>();

  spine_array_float spine_path_constraint_position_timeline_get_curves(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_curves(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_path_constraint_position_timeline)>>(
      'spine_path_constraint_position_timeline_get_curves');
  late final _spine_path_constraint_position_timeline_get_curves =
      _spine_path_constraint_position_timeline_get_curvesPtr.asFunction<
          spine_array_float Function(
              spine_path_constraint_position_timeline)>();

  int spine_path_constraint_position_timeline_get_frame_entries(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_frame_entriesPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_get_frame_entries');
  late final _spine_path_constraint_position_timeline_get_frame_entries =
      _spine_path_constraint_position_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_path_constraint_position_timeline)>();

  int spine_path_constraint_position_timeline_get_frame_count(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_frame_countPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_get_frame_count');
  late final _spine_path_constraint_position_timeline_get_frame_count =
      _spine_path_constraint_position_timeline_get_frame_countPtr
          .asFunction<int Function(spine_path_constraint_position_timeline)>();

  spine_array_float spine_path_constraint_position_timeline_get_frames(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_frames(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_path_constraint_position_timeline)>>(
      'spine_path_constraint_position_timeline_get_frames');
  late final _spine_path_constraint_position_timeline_get_frames =
      _spine_path_constraint_position_timeline_get_framesPtr.asFunction<
          spine_array_float Function(
              spine_path_constraint_position_timeline)>();

  double spine_path_constraint_position_timeline_get_duration(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_duration(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<
              ffi.Float Function(spine_path_constraint_position_timeline)>>(
      'spine_path_constraint_position_timeline_get_duration');
  late final _spine_path_constraint_position_timeline_get_duration =
      _spine_path_constraint_position_timeline_get_durationPtr.asFunction<
          double Function(spine_path_constraint_position_timeline)>();

  spine_array_property_id
      spine_path_constraint_position_timeline_get_property_ids(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_property_idsPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_array_property_id Function(
                      spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_get_property_ids');
  late final _spine_path_constraint_position_timeline_get_property_ids =
      _spine_path_constraint_position_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(
              spine_path_constraint_position_timeline)>();

  int spine_path_constraint_position_timeline_get_constraint_index(
    spine_path_constraint_position_timeline self,
  ) {
    return _spine_path_constraint_position_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_path_constraint_position_timeline_get_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(spine_path_constraint_position_timeline)>>(
          'spine_path_constraint_position_timeline_get_constraint_index');
  late final _spine_path_constraint_position_timeline_get_constraint_index =
      _spine_path_constraint_position_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_path_constraint_position_timeline)>();

  void spine_path_constraint_position_timeline_set_constraint_index(
    spine_path_constraint_position_timeline self,
    int inValue,
  ) {
    return _spine_path_constraint_position_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_path_constraint_position_timeline_set_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_path_constraint_position_timeline, ffi.Int)>>(
          'spine_path_constraint_position_timeline_set_constraint_index');
  late final _spine_path_constraint_position_timeline_set_constraint_index =
      _spine_path_constraint_position_timeline_set_constraint_indexPtr
          .asFunction<
              void Function(spine_path_constraint_position_timeline, int)>();

  spine_rtti spine_path_constraint_position_timeline_rtti() {
    return _spine_path_constraint_position_timeline_rtti();
  }

  late final _spine_path_constraint_position_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_path_constraint_position_timeline_rtti');
  late final _spine_path_constraint_position_timeline_rtti =
      _spine_path_constraint_position_timeline_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_path_constraint_spacing_timeline
      spine_path_constraint_spacing_timeline_create(
    int frameCount,
    int bezierCount,
    int constraintIndex,
  ) {
    return _spine_path_constraint_spacing_timeline_create(
      frameCount,
      bezierCount,
      constraintIndex,
    );
  }

  late final _spine_path_constraint_spacing_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_path_constraint_spacing_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_path_constraint_spacing_timeline_create');
  late final _spine_path_constraint_spacing_timeline_create =
      _spine_path_constraint_spacing_timeline_createPtr.asFunction<
          spine_path_constraint_spacing_timeline Function(int, int, int)>();

  void spine_path_constraint_spacing_timeline_dispose(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_dispose(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_path_constraint_spacing_timeline)>>(
      'spine_path_constraint_spacing_timeline_dispose');
  late final _spine_path_constraint_spacing_timeline_dispose =
      _spine_path_constraint_spacing_timeline_disposePtr
          .asFunction<void Function(spine_path_constraint_spacing_timeline)>();

  spine_rtti spine_path_constraint_spacing_timeline_get_rtti(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_rtti(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_path_constraint_spacing_timeline)>>(
      'spine_path_constraint_spacing_timeline_get_rtti');
  late final _spine_path_constraint_spacing_timeline_get_rtti =
      _spine_path_constraint_spacing_timeline_get_rttiPtr.asFunction<
          spine_rtti Function(spine_path_constraint_spacing_timeline)>();

  void spine_path_constraint_spacing_timeline_apply(
    spine_path_constraint_spacing_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_path_constraint_spacing_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_path_constraint_spacing_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_constraint_spacing_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_path_constraint_spacing_timeline_apply');
  late final _spine_path_constraint_spacing_timeline_apply =
      _spine_path_constraint_spacing_timeline_applyPtr.asFunction<
          void Function(spine_path_constraint_spacing_timeline, spine_skeleton,
              double, double, spine_array_event, double, int, int, bool)>();

  void spine_path_constraint_spacing_timeline_set_frame(
    spine_path_constraint_spacing_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_path_constraint_spacing_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_path_constraint_spacing_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_constraint_spacing_timeline,
              ffi.Size,
              ffi.Float,
              ffi.Float)>>('spine_path_constraint_spacing_timeline_set_frame');
  late final _spine_path_constraint_spacing_timeline_set_frame =
      _spine_path_constraint_spacing_timeline_set_framePtr.asFunction<
          void Function(
              spine_path_constraint_spacing_timeline, int, double, double)>();

  double spine_path_constraint_spacing_timeline_get_curve_value(
    spine_path_constraint_spacing_timeline self,
    double time,
  ) {
    return _spine_path_constraint_spacing_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_curve_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_path_constraint_spacing_timeline, ffi.Float)>>(
          'spine_path_constraint_spacing_timeline_get_curve_value');
  late final _spine_path_constraint_spacing_timeline_get_curve_value =
      _spine_path_constraint_spacing_timeline_get_curve_valuePtr.asFunction<
          double Function(spine_path_constraint_spacing_timeline, double)>();

  double spine_path_constraint_spacing_timeline_get_relative_value(
    spine_path_constraint_spacing_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_path_constraint_spacing_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_relative_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_path_constraint_spacing_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_path_constraint_spacing_timeline_get_relative_value');
  late final _spine_path_constraint_spacing_timeline_get_relative_value =
      _spine_path_constraint_spacing_timeline_get_relative_valuePtr.asFunction<
          double Function(spine_path_constraint_spacing_timeline, double,
              double, int, double, double)>();

  double spine_path_constraint_spacing_timeline_get_absolute_value_1(
    spine_path_constraint_spacing_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_path_constraint_spacing_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_absolute_value_1Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_path_constraint_spacing_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_path_constraint_spacing_timeline_get_absolute_value_1');
  late final _spine_path_constraint_spacing_timeline_get_absolute_value_1 =
      _spine_path_constraint_spacing_timeline_get_absolute_value_1Ptr
          .asFunction<
              double Function(spine_path_constraint_spacing_timeline, double,
                  double, int, double, double)>();

  double spine_path_constraint_spacing_timeline_get_absolute_value_2(
    spine_path_constraint_spacing_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_path_constraint_spacing_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_absolute_value_2Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_path_constraint_spacing_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_path_constraint_spacing_timeline_get_absolute_value_2');
  late final _spine_path_constraint_spacing_timeline_get_absolute_value_2 =
      _spine_path_constraint_spacing_timeline_get_absolute_value_2Ptr
          .asFunction<
              double Function(spine_path_constraint_spacing_timeline, double,
                  double, int, double, double, double)>();

  double spine_path_constraint_spacing_timeline_get_scale_value(
    spine_path_constraint_spacing_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_path_constraint_spacing_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_scale_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_path_constraint_spacing_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_path_constraint_spacing_timeline_get_scale_value');
  late final _spine_path_constraint_spacing_timeline_get_scale_value =
      _spine_path_constraint_spacing_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_path_constraint_spacing_timeline, double,
              double, int, int, double, double)>();

  void spine_path_constraint_spacing_timeline_set_linear(
    spine_path_constraint_spacing_timeline self,
    int frame,
  ) {
    return _spine_path_constraint_spacing_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_path_constraint_spacing_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_spacing_timeline,
              ffi.Size)>>('spine_path_constraint_spacing_timeline_set_linear');
  late final _spine_path_constraint_spacing_timeline_set_linear =
      _spine_path_constraint_spacing_timeline_set_linearPtr.asFunction<
          void Function(spine_path_constraint_spacing_timeline, int)>();

  void spine_path_constraint_spacing_timeline_set_stepped(
    spine_path_constraint_spacing_timeline self,
    int frame,
  ) {
    return _spine_path_constraint_spacing_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_path_constraint_spacing_timeline_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_path_constraint_spacing_timeline,
              ffi.Size)>>('spine_path_constraint_spacing_timeline_set_stepped');
  late final _spine_path_constraint_spacing_timeline_set_stepped =
      _spine_path_constraint_spacing_timeline_set_steppedPtr.asFunction<
          void Function(spine_path_constraint_spacing_timeline, int)>();

  void spine_path_constraint_spacing_timeline_set_bezier(
    spine_path_constraint_spacing_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_path_constraint_spacing_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_path_constraint_spacing_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_path_constraint_spacing_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_path_constraint_spacing_timeline_set_bezier');
  late final _spine_path_constraint_spacing_timeline_set_bezier =
      _spine_path_constraint_spacing_timeline_set_bezierPtr.asFunction<
          void Function(
              spine_path_constraint_spacing_timeline,
              int,
              int,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double)>();

  double spine_path_constraint_spacing_timeline_get_bezier_value(
    spine_path_constraint_spacing_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_path_constraint_spacing_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_bezier_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_path_constraint_spacing_timeline,
                      ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_path_constraint_spacing_timeline_get_bezier_value');
  late final _spine_path_constraint_spacing_timeline_get_bezier_value =
      _spine_path_constraint_spacing_timeline_get_bezier_valuePtr.asFunction<
          double Function(
              spine_path_constraint_spacing_timeline, double, int, int, int)>();

  spine_array_float spine_path_constraint_spacing_timeline_get_curves(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_curves(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_path_constraint_spacing_timeline)>>(
      'spine_path_constraint_spacing_timeline_get_curves');
  late final _spine_path_constraint_spacing_timeline_get_curves =
      _spine_path_constraint_spacing_timeline_get_curvesPtr.asFunction<
          spine_array_float Function(spine_path_constraint_spacing_timeline)>();

  int spine_path_constraint_spacing_timeline_get_frame_entries(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_frame_entriesPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_get_frame_entries');
  late final _spine_path_constraint_spacing_timeline_get_frame_entries =
      _spine_path_constraint_spacing_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_path_constraint_spacing_timeline)>();

  int spine_path_constraint_spacing_timeline_get_frame_count(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_frame_countPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_get_frame_count');
  late final _spine_path_constraint_spacing_timeline_get_frame_count =
      _spine_path_constraint_spacing_timeline_get_frame_countPtr
          .asFunction<int Function(spine_path_constraint_spacing_timeline)>();

  spine_array_float spine_path_constraint_spacing_timeline_get_frames(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_frames(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_path_constraint_spacing_timeline)>>(
      'spine_path_constraint_spacing_timeline_get_frames');
  late final _spine_path_constraint_spacing_timeline_get_frames =
      _spine_path_constraint_spacing_timeline_get_framesPtr.asFunction<
          spine_array_float Function(spine_path_constraint_spacing_timeline)>();

  double spine_path_constraint_spacing_timeline_get_duration(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_duration(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<
              ffi.Float Function(spine_path_constraint_spacing_timeline)>>(
      'spine_path_constraint_spacing_timeline_get_duration');
  late final _spine_path_constraint_spacing_timeline_get_duration =
      _spine_path_constraint_spacing_timeline_get_durationPtr.asFunction<
          double Function(spine_path_constraint_spacing_timeline)>();

  spine_array_property_id
      spine_path_constraint_spacing_timeline_get_property_ids(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_property_idsPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_array_property_id Function(
                      spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_get_property_ids');
  late final _spine_path_constraint_spacing_timeline_get_property_ids =
      _spine_path_constraint_spacing_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(
              spine_path_constraint_spacing_timeline)>();

  int spine_path_constraint_spacing_timeline_get_constraint_index(
    spine_path_constraint_spacing_timeline self,
  ) {
    return _spine_path_constraint_spacing_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_path_constraint_spacing_timeline_get_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(spine_path_constraint_spacing_timeline)>>(
          'spine_path_constraint_spacing_timeline_get_constraint_index');
  late final _spine_path_constraint_spacing_timeline_get_constraint_index =
      _spine_path_constraint_spacing_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_path_constraint_spacing_timeline)>();

  void spine_path_constraint_spacing_timeline_set_constraint_index(
    spine_path_constraint_spacing_timeline self,
    int inValue,
  ) {
    return _spine_path_constraint_spacing_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_path_constraint_spacing_timeline_set_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_path_constraint_spacing_timeline, ffi.Int)>>(
          'spine_path_constraint_spacing_timeline_set_constraint_index');
  late final _spine_path_constraint_spacing_timeline_set_constraint_index =
      _spine_path_constraint_spacing_timeline_set_constraint_indexPtr
          .asFunction<
              void Function(spine_path_constraint_spacing_timeline, int)>();

  spine_rtti spine_path_constraint_spacing_timeline_rtti() {
    return _spine_path_constraint_spacing_timeline_rtti();
  }

  late final _spine_path_constraint_spacing_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_path_constraint_spacing_timeline_rtti');
  late final _spine_path_constraint_spacing_timeline_rtti =
      _spine_path_constraint_spacing_timeline_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_physics_constraint spine_physics_constraint_create(
    spine_physics_constraint_data data,
    spine_skeleton skeleton,
  ) {
    return _spine_physics_constraint_create(
      data,
      skeleton,
    );
  }

  late final _spine_physics_constraint_createPtr = _lookup<
      ffi.NativeFunction<
          spine_physics_constraint Function(spine_physics_constraint_data,
              spine_skeleton)>>('spine_physics_constraint_create');
  late final _spine_physics_constraint_create =
      _spine_physics_constraint_createPtr.asFunction<
          spine_physics_constraint Function(
              spine_physics_constraint_data, spine_skeleton)>();

  void spine_physics_constraint_dispose(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint)>>(
          'spine_physics_constraint_dispose');
  late final _spine_physics_constraint_dispose =
      _spine_physics_constraint_disposePtr
          .asFunction<void Function(spine_physics_constraint)>();

  spine_rtti spine_physics_constraint_get_rtti(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_physics_constraint)>>(
      'spine_physics_constraint_get_rtti');
  late final _spine_physics_constraint_get_rtti =
      _spine_physics_constraint_get_rttiPtr
          .asFunction<spine_rtti Function(spine_physics_constraint)>();

  void spine_physics_constraint_update(
    spine_physics_constraint self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_physics_constraint_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_physics_constraint_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint, spine_skeleton,
              ffi.Int32)>>('spine_physics_constraint_update');
  late final _spine_physics_constraint_update =
      _spine_physics_constraint_updatePtr.asFunction<
          void Function(spine_physics_constraint, spine_skeleton, int)>();

  void spine_physics_constraint_sort(
    spine_physics_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_physics_constraint_sort(
      self,
      skeleton,
    );
  }

  late final _spine_physics_constraint_sortPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint,
              spine_skeleton)>>('spine_physics_constraint_sort');
  late final _spine_physics_constraint_sort = _spine_physics_constraint_sortPtr
      .asFunction<void Function(spine_physics_constraint, spine_skeleton)>();

  bool spine_physics_constraint_is_source_active(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_is_source_active(
      self,
    );
  }

  late final _spine_physics_constraint_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint)>>(
          'spine_physics_constraint_is_source_active');
  late final _spine_physics_constraint_is_source_active =
      _spine_physics_constraint_is_source_activePtr
          .asFunction<bool Function(spine_physics_constraint)>();

  spine_physics_constraint spine_physics_constraint_copy(
    spine_physics_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_physics_constraint_copy(
      self,
      skeleton,
    );
  }

  late final _spine_physics_constraint_copyPtr = _lookup<
      ffi.NativeFunction<
          spine_physics_constraint Function(spine_physics_constraint,
              spine_skeleton)>>('spine_physics_constraint_copy');
  late final _spine_physics_constraint_copy =
      _spine_physics_constraint_copyPtr.asFunction<
          spine_physics_constraint Function(
              spine_physics_constraint, spine_skeleton)>();

  void spine_physics_constraint_reset(
    spine_physics_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_physics_constraint_reset(
      self,
      skeleton,
    );
  }

  late final _spine_physics_constraint_resetPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint,
              spine_skeleton)>>('spine_physics_constraint_reset');
  late final _spine_physics_constraint_reset =
      _spine_physics_constraint_resetPtr.asFunction<
          void Function(spine_physics_constraint, spine_skeleton)>();

  void spine_physics_constraint_translate(
    spine_physics_constraint self,
    double x,
    double y,
  ) {
    return _spine_physics_constraint_translate(
      self,
      x,
      y,
    );
  }

  late final _spine_physics_constraint_translatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_translate');
  late final _spine_physics_constraint_translate =
      _spine_physics_constraint_translatePtr.asFunction<
          void Function(spine_physics_constraint, double, double)>();

  void spine_physics_constraint_rotate(
    spine_physics_constraint self,
    double x,
    double y,
    double degrees,
  ) {
    return _spine_physics_constraint_rotate(
      self,
      x,
      y,
      degrees,
    );
  }

  late final _spine_physics_constraint_rotatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_physics_constraint_rotate');
  late final _spine_physics_constraint_rotate =
      _spine_physics_constraint_rotatePtr.asFunction<
          void Function(spine_physics_constraint, double, double, double)>();

  spine_bone_pose spine_physics_constraint_get_bone(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_get_bone(
      self,
    );
  }

  late final _spine_physics_constraint_get_bonePtr = _lookup<
          ffi
          .NativeFunction<spine_bone_pose Function(spine_physics_constraint)>>(
      'spine_physics_constraint_get_bone');
  late final _spine_physics_constraint_get_bone =
      _spine_physics_constraint_get_bonePtr
          .asFunction<spine_bone_pose Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_bone(
    spine_physics_constraint self,
    spine_bone_pose bone,
  ) {
    return _spine_physics_constraint_set_bone(
      self,
      bone,
    );
  }

  late final _spine_physics_constraint_set_bonePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint,
              spine_bone_pose)>>('spine_physics_constraint_set_bone');
  late final _spine_physics_constraint_set_bone =
      _spine_physics_constraint_set_bonePtr.asFunction<
          void Function(spine_physics_constraint, spine_bone_pose)>();

  spine_physics_constraint_data spine_physics_constraint_get_data(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_get_data(
      self,
    );
  }

  late final _spine_physics_constraint_get_dataPtr = _lookup<
      ffi.NativeFunction<
          spine_physics_constraint_data Function(
              spine_physics_constraint)>>('spine_physics_constraint_get_data');
  late final _spine_physics_constraint_get_data =
      _spine_physics_constraint_get_dataPtr.asFunction<
          spine_physics_constraint_data Function(spine_physics_constraint)>();

  spine_physics_constraint_pose spine_physics_constraint_get_pose(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_get_pose(
      self,
    );
  }

  late final _spine_physics_constraint_get_posePtr = _lookup<
      ffi.NativeFunction<
          spine_physics_constraint_pose Function(
              spine_physics_constraint)>>('spine_physics_constraint_get_pose');
  late final _spine_physics_constraint_get_pose =
      _spine_physics_constraint_get_posePtr.asFunction<
          spine_physics_constraint_pose Function(spine_physics_constraint)>();

  spine_physics_constraint_pose spine_physics_constraint_get_applied_pose(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_get_applied_pose(
      self,
    );
  }

  late final _spine_physics_constraint_get_applied_posePtr = _lookup<
          ffi.NativeFunction<
              spine_physics_constraint_pose Function(
                  spine_physics_constraint)>>(
      'spine_physics_constraint_get_applied_pose');
  late final _spine_physics_constraint_get_applied_pose =
      _spine_physics_constraint_get_applied_posePtr.asFunction<
          spine_physics_constraint_pose Function(spine_physics_constraint)>();

  void spine_physics_constraint_reset_constrained(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_reset_constrained(
      self,
    );
  }

  late final _spine_physics_constraint_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint)>>(
          'spine_physics_constraint_reset_constrained');
  late final _spine_physics_constraint_reset_constrained =
      _spine_physics_constraint_reset_constrainedPtr
          .asFunction<void Function(spine_physics_constraint)>();

  void spine_physics_constraint_constrained(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_constrained(
      self,
    );
  }

  late final _spine_physics_constraint_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint)>>(
          'spine_physics_constraint_constrained');
  late final _spine_physics_constraint_constrained =
      _spine_physics_constraint_constrainedPtr
          .asFunction<void Function(spine_physics_constraint)>();

  bool spine_physics_constraint_is_pose_equal_to_applied(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_physics_constraint_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint)>>(
          'spine_physics_constraint_is_pose_equal_to_applied');
  late final _spine_physics_constraint_is_pose_equal_to_applied =
      _spine_physics_constraint_is_pose_equal_to_appliedPtr
          .asFunction<bool Function(spine_physics_constraint)>();

  bool spine_physics_constraint_is_active(
    spine_physics_constraint self,
  ) {
    return _spine_physics_constraint_is_active(
      self,
    );
  }

  late final _spine_physics_constraint_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint)>>(
          'spine_physics_constraint_is_active');
  late final _spine_physics_constraint_is_active =
      _spine_physics_constraint_is_activePtr
          .asFunction<bool Function(spine_physics_constraint)>();

  void spine_physics_constraint_set_active(
    spine_physics_constraint self,
    bool active,
  ) {
    return _spine_physics_constraint_set_active(
      self,
      active,
    );
  }

  late final _spine_physics_constraint_set_activePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint,
              ffi.Bool)>>('spine_physics_constraint_set_active');
  late final _spine_physics_constraint_set_active =
      _spine_physics_constraint_set_activePtr
          .asFunction<void Function(spine_physics_constraint, bool)>();

  spine_rtti spine_physics_constraint_rtti() {
    return _spine_physics_constraint_rtti();
  }

  late final _spine_physics_constraint_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_physics_constraint_rtti');
  late final _spine_physics_constraint_rtti =
      _spine_physics_constraint_rttiPtr.asFunction<spine_rtti Function()>();

  spine_physics_constraint_damping_timeline
      spine_physics_constraint_damping_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_damping_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_damping_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_physics_constraint_damping_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_physics_constraint_damping_timeline_create');
  late final _spine_physics_constraint_damping_timeline_create =
      _spine_physics_constraint_damping_timeline_createPtr.asFunction<
          spine_physics_constraint_damping_timeline Function(int, int, int)>();

  void spine_physics_constraint_damping_timeline_dispose(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_damping_timeline)>>(
      'spine_physics_constraint_damping_timeline_dispose');
  late final _spine_physics_constraint_damping_timeline_dispose =
      _spine_physics_constraint_damping_timeline_disposePtr.asFunction<
          void Function(spine_physics_constraint_damping_timeline)>();

  spine_rtti spine_physics_constraint_damping_timeline_get_rtti(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_physics_constraint_damping_timeline)>>(
      'spine_physics_constraint_damping_timeline_get_rtti');
  late final _spine_physics_constraint_damping_timeline_get_rtti =
      _spine_physics_constraint_damping_timeline_get_rttiPtr.asFunction<
          spine_rtti Function(spine_physics_constraint_damping_timeline)>();

  void spine_physics_constraint_damping_timeline_apply(
    spine_physics_constraint_damping_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_damping_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_damping_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_damping_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_damping_timeline_apply');
  late final _spine_physics_constraint_damping_timeline_apply =
      _spine_physics_constraint_damping_timeline_applyPtr.asFunction<
          void Function(
              spine_physics_constraint_damping_timeline,
              spine_skeleton,
              double,
              double,
              spine_array_event,
              double,
              int,
              int,
              bool)>();

  void spine_physics_constraint_damping_timeline_set_frame(
    spine_physics_constraint_damping_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_damping_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_damping_timeline_set_framePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_damping_timeline,
                  ffi.Size, ffi.Float, ffi.Float)>>(
      'spine_physics_constraint_damping_timeline_set_frame');
  late final _spine_physics_constraint_damping_timeline_set_frame =
      _spine_physics_constraint_damping_timeline_set_framePtr.asFunction<
          void Function(spine_physics_constraint_damping_timeline, int, double,
              double)>();

  double spine_physics_constraint_damping_timeline_get_curve_value(
    spine_physics_constraint_damping_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_damping_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_curve_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_damping_timeline, ffi.Float)>>(
          'spine_physics_constraint_damping_timeline_get_curve_value');
  late final _spine_physics_constraint_damping_timeline_get_curve_value =
      _spine_physics_constraint_damping_timeline_get_curve_valuePtr.asFunction<
          double Function(spine_physics_constraint_damping_timeline, double)>();

  double spine_physics_constraint_damping_timeline_get_relative_value(
    spine_physics_constraint_damping_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_damping_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_relative_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_damping_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_damping_timeline_get_relative_value');
  late final _spine_physics_constraint_damping_timeline_get_relative_value =
      _spine_physics_constraint_damping_timeline_get_relative_valuePtr
          .asFunction<
              double Function(spine_physics_constraint_damping_timeline, double,
                  double, int, double, double)>();

  double spine_physics_constraint_damping_timeline_get_absolute_value_1(
    spine_physics_constraint_damping_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_damping_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_absolute_value_1Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_damping_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_damping_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_damping_timeline_get_absolute_value_1 =
      _spine_physics_constraint_damping_timeline_get_absolute_value_1Ptr
          .asFunction<
              double Function(spine_physics_constraint_damping_timeline, double,
                  double, int, double, double)>();

  double spine_physics_constraint_damping_timeline_get_absolute_value_2(
    spine_physics_constraint_damping_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_damping_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_absolute_value_2Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_damping_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_damping_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_damping_timeline_get_absolute_value_2 =
      _spine_physics_constraint_damping_timeline_get_absolute_value_2Ptr
          .asFunction<
              double Function(spine_physics_constraint_damping_timeline, double,
                  double, int, double, double, double)>();

  double spine_physics_constraint_damping_timeline_get_scale_value(
    spine_physics_constraint_damping_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_damping_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_scale_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_damping_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_damping_timeline_get_scale_value');
  late final _spine_physics_constraint_damping_timeline_get_scale_value =
      _spine_physics_constraint_damping_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_damping_timeline, double,
              double, int, int, double, double)>();

  void spine_physics_constraint_damping_timeline_set_linear(
    spine_physics_constraint_damping_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_damping_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_damping_timeline_set_linearPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  spine_physics_constraint_damping_timeline, ffi.Size)>>(
      'spine_physics_constraint_damping_timeline_set_linear');
  late final _spine_physics_constraint_damping_timeline_set_linear =
      _spine_physics_constraint_damping_timeline_set_linearPtr.asFunction<
          void Function(spine_physics_constraint_damping_timeline, int)>();

  void spine_physics_constraint_damping_timeline_set_stepped(
    spine_physics_constraint_damping_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_damping_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_damping_timeline_set_steppedPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_damping_timeline, ffi.Size)>>(
          'spine_physics_constraint_damping_timeline_set_stepped');
  late final _spine_physics_constraint_damping_timeline_set_stepped =
      _spine_physics_constraint_damping_timeline_set_steppedPtr.asFunction<
          void Function(spine_physics_constraint_damping_timeline, int)>();

  void spine_physics_constraint_damping_timeline_set_bezier(
    spine_physics_constraint_damping_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_damping_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_damping_timeline_set_bezierPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  spine_physics_constraint_damping_timeline,
                  ffi.Size,
                  ffi.Size,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float)>>(
      'spine_physics_constraint_damping_timeline_set_bezier');
  late final _spine_physics_constraint_damping_timeline_set_bezier =
      _spine_physics_constraint_damping_timeline_set_bezierPtr.asFunction<
          void Function(
              spine_physics_constraint_damping_timeline,
              int,
              int,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double)>();

  double spine_physics_constraint_damping_timeline_get_bezier_value(
    spine_physics_constraint_damping_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_damping_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_bezier_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_damping_timeline,
                      ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_physics_constraint_damping_timeline_get_bezier_value');
  late final _spine_physics_constraint_damping_timeline_get_bezier_value =
      _spine_physics_constraint_damping_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_physics_constraint_damping_timeline, double,
              int, int, int)>();

  spine_array_float spine_physics_constraint_damping_timeline_get_curves(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_physics_constraint_damping_timeline)>>(
      'spine_physics_constraint_damping_timeline_get_curves');
  late final _spine_physics_constraint_damping_timeline_get_curves =
      _spine_physics_constraint_damping_timeline_get_curvesPtr.asFunction<
          spine_array_float Function(
              spine_physics_constraint_damping_timeline)>();

  int spine_physics_constraint_damping_timeline_get_frame_entries(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_frame_entriesPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(
                      spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_get_frame_entries');
  late final _spine_physics_constraint_damping_timeline_get_frame_entries =
      _spine_physics_constraint_damping_timeline_get_frame_entriesPtr
          .asFunction<
              int Function(spine_physics_constraint_damping_timeline)>();

  int spine_physics_constraint_damping_timeline_get_frame_count(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_frame_countPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(
                      spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_get_frame_count');
  late final _spine_physics_constraint_damping_timeline_get_frame_count =
      _spine_physics_constraint_damping_timeline_get_frame_countPtr.asFunction<
          int Function(spine_physics_constraint_damping_timeline)>();

  spine_array_float spine_physics_constraint_damping_timeline_get_frames(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_physics_constraint_damping_timeline)>>(
      'spine_physics_constraint_damping_timeline_get_frames');
  late final _spine_physics_constraint_damping_timeline_get_frames =
      _spine_physics_constraint_damping_timeline_get_framesPtr.asFunction<
          spine_array_float Function(
              spine_physics_constraint_damping_timeline)>();

  double spine_physics_constraint_damping_timeline_get_duration(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_durationPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_get_duration');
  late final _spine_physics_constraint_damping_timeline_get_duration =
      _spine_physics_constraint_damping_timeline_get_durationPtr.asFunction<
          double Function(spine_physics_constraint_damping_timeline)>();

  spine_array_property_id
      spine_physics_constraint_damping_timeline_get_property_ids(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_property_idsPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_array_property_id Function(
                      spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_get_property_ids');
  late final _spine_physics_constraint_damping_timeline_get_property_ids =
      _spine_physics_constraint_damping_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(
              spine_physics_constraint_damping_timeline)>();

  int spine_physics_constraint_damping_timeline_get_constraint_index(
    spine_physics_constraint_damping_timeline self,
  ) {
    return _spine_physics_constraint_damping_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_damping_timeline_get_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(spine_physics_constraint_damping_timeline)>>(
          'spine_physics_constraint_damping_timeline_get_constraint_index');
  late final _spine_physics_constraint_damping_timeline_get_constraint_index =
      _spine_physics_constraint_damping_timeline_get_constraint_indexPtr
          .asFunction<
              int Function(spine_physics_constraint_damping_timeline)>();

  void spine_physics_constraint_damping_timeline_set_constraint_index(
    spine_physics_constraint_damping_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_damping_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_damping_timeline_set_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_damping_timeline, ffi.Int)>>(
          'spine_physics_constraint_damping_timeline_set_constraint_index');
  late final _spine_physics_constraint_damping_timeline_set_constraint_index =
      _spine_physics_constraint_damping_timeline_set_constraint_indexPtr
          .asFunction<
              void Function(spine_physics_constraint_damping_timeline, int)>();

  spine_rtti spine_physics_constraint_damping_timeline_rtti() {
    return _spine_physics_constraint_damping_timeline_rtti();
  }

  late final _spine_physics_constraint_damping_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_physics_constraint_damping_timeline_rtti');
  late final _spine_physics_constraint_damping_timeline_rtti =
      _spine_physics_constraint_damping_timeline_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_physics_constraint_data spine_physics_constraint_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_physics_constraint_data_create(
      name,
    );
  }

  late final _spine_physics_constraint_data_createPtr = _lookup<
      ffi.NativeFunction<
          spine_physics_constraint_data Function(
              ffi.Pointer<ffi.Char>)>>('spine_physics_constraint_data_create');
  late final _spine_physics_constraint_data_create =
      _spine_physics_constraint_data_createPtr.asFunction<
          spine_physics_constraint_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_physics_constraint_data_dispose(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_data_disposePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_dispose');
  late final _spine_physics_constraint_data_dispose =
      _spine_physics_constraint_data_disposePtr
          .asFunction<void Function(spine_physics_constraint_data)>();

  spine_rtti spine_physics_constraint_data_get_rtti(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_rttiPtr = _lookup<
          ffi
          .NativeFunction<spine_rtti Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_rtti');
  late final _spine_physics_constraint_data_get_rtti =
      _spine_physics_constraint_data_get_rttiPtr
          .asFunction<spine_rtti Function(spine_physics_constraint_data)>();

  spine_constraint spine_physics_constraint_data_create_method(
    spine_physics_constraint_data self,
    spine_skeleton skeleton,
  ) {
    return _spine_physics_constraint_data_create_method(
      self,
      skeleton,
    );
  }

  late final _spine_physics_constraint_data_create_methodPtr = _lookup<
      ffi.NativeFunction<
          spine_constraint Function(spine_physics_constraint_data,
              spine_skeleton)>>('spine_physics_constraint_data_create_method');
  late final _spine_physics_constraint_data_create_method =
      _spine_physics_constraint_data_create_methodPtr.asFunction<
          spine_constraint Function(
              spine_physics_constraint_data, spine_skeleton)>();

  spine_bone_data spine_physics_constraint_data_get_bone(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_bone(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_bonePtr = _lookup<
          ffi.NativeFunction<
              spine_bone_data Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_bone');
  late final _spine_physics_constraint_data_get_bone =
      _spine_physics_constraint_data_get_bonePtr.asFunction<
          spine_bone_data Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_bone(
    spine_physics_constraint_data self,
    spine_bone_data bone,
  ) {
    return _spine_physics_constraint_data_set_bone(
      self,
      bone,
    );
  }

  late final _spine_physics_constraint_data_set_bonePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              spine_bone_data)>>('spine_physics_constraint_data_set_bone');
  late final _spine_physics_constraint_data_set_bone =
      _spine_physics_constraint_data_set_bonePtr.asFunction<
          void Function(spine_physics_constraint_data, spine_bone_data)>();

  double spine_physics_constraint_data_get_step(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_step(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_stepPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_step');
  late final _spine_physics_constraint_data_get_step =
      _spine_physics_constraint_data_get_stepPtr
          .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_step(
    spine_physics_constraint_data self,
    double step,
  ) {
    return _spine_physics_constraint_data_set_step(
      self,
      step,
    );
  }

  late final _spine_physics_constraint_data_set_stepPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Float)>>('spine_physics_constraint_data_set_step');
  late final _spine_physics_constraint_data_set_step =
      _spine_physics_constraint_data_set_stepPtr
          .asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_x(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_x(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_xPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_x');
  late final _spine_physics_constraint_data_get_x =
      _spine_physics_constraint_data_get_xPtr
          .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_x(
    spine_physics_constraint_data self,
    double x,
  ) {
    return _spine_physics_constraint_data_set_x(
      self,
      x,
    );
  }

  late final _spine_physics_constraint_data_set_xPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Float)>>('spine_physics_constraint_data_set_x');
  late final _spine_physics_constraint_data_set_x =
      _spine_physics_constraint_data_set_xPtr
          .asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_y(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_y(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_yPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_y');
  late final _spine_physics_constraint_data_get_y =
      _spine_physics_constraint_data_get_yPtr
          .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_y(
    spine_physics_constraint_data self,
    double y,
  ) {
    return _spine_physics_constraint_data_set_y(
      self,
      y,
    );
  }

  late final _spine_physics_constraint_data_set_yPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Float)>>('spine_physics_constraint_data_set_y');
  late final _spine_physics_constraint_data_set_y =
      _spine_physics_constraint_data_set_yPtr
          .asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_rotate(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_rotate(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_rotatePtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_rotate');
  late final _spine_physics_constraint_data_get_rotate =
      _spine_physics_constraint_data_get_rotatePtr
          .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_rotate(
    spine_physics_constraint_data self,
    double rotate,
  ) {
    return _spine_physics_constraint_data_set_rotate(
      self,
      rotate,
    );
  }

  late final _spine_physics_constraint_data_set_rotatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Float)>>('spine_physics_constraint_data_set_rotate');
  late final _spine_physics_constraint_data_set_rotate =
      _spine_physics_constraint_data_set_rotatePtr
          .asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_scale_x(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_scale_x(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_scale_xPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_scale_x');
  late final _spine_physics_constraint_data_get_scale_x =
      _spine_physics_constraint_data_get_scale_xPtr
          .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_scale_x(
    spine_physics_constraint_data self,
    double scaleX,
  ) {
    return _spine_physics_constraint_data_set_scale_x(
      self,
      scaleX,
    );
  }

  late final _spine_physics_constraint_data_set_scale_xPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Float)>>('spine_physics_constraint_data_set_scale_x');
  late final _spine_physics_constraint_data_set_scale_x =
      _spine_physics_constraint_data_set_scale_xPtr
          .asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_shear_x(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_shear_x(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_shear_xPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_shear_x');
  late final _spine_physics_constraint_data_get_shear_x =
      _spine_physics_constraint_data_get_shear_xPtr
          .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_shear_x(
    spine_physics_constraint_data self,
    double shearX,
  ) {
    return _spine_physics_constraint_data_set_shear_x(
      self,
      shearX,
    );
  }

  late final _spine_physics_constraint_data_set_shear_xPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Float)>>('spine_physics_constraint_data_set_shear_x');
  late final _spine_physics_constraint_data_set_shear_x =
      _spine_physics_constraint_data_set_shear_xPtr
          .asFunction<void Function(spine_physics_constraint_data, double)>();

  double spine_physics_constraint_data_get_limit(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_limit(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_limitPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_limit');
  late final _spine_physics_constraint_data_get_limit =
      _spine_physics_constraint_data_get_limitPtr
          .asFunction<double Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_limit(
    spine_physics_constraint_data self,
    double limit,
  ) {
    return _spine_physics_constraint_data_set_limit(
      self,
      limit,
    );
  }

  late final _spine_physics_constraint_data_set_limitPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Float)>>('spine_physics_constraint_data_set_limit');
  late final _spine_physics_constraint_data_set_limit =
      _spine_physics_constraint_data_set_limitPtr
          .asFunction<void Function(spine_physics_constraint_data, double)>();

  bool spine_physics_constraint_data_get_inertia_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_inertia_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_inertia_globalPtr = _lookup<
          ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_inertia_global');
  late final _spine_physics_constraint_data_get_inertia_global =
      _spine_physics_constraint_data_get_inertia_globalPtr
          .asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_inertia_global(
    spine_physics_constraint_data self,
    bool inertiaGlobal,
  ) {
    return _spine_physics_constraint_data_set_inertia_global(
      self,
      inertiaGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_inertia_globalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Bool)>>('spine_physics_constraint_data_set_inertia_global');
  late final _spine_physics_constraint_data_set_inertia_global =
      _spine_physics_constraint_data_set_inertia_globalPtr
          .asFunction<void Function(spine_physics_constraint_data, bool)>();

  bool spine_physics_constraint_data_get_strength_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_strength_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_strength_globalPtr = _lookup<
          ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_strength_global');
  late final _spine_physics_constraint_data_get_strength_global =
      _spine_physics_constraint_data_get_strength_globalPtr
          .asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_strength_global(
    spine_physics_constraint_data self,
    bool strengthGlobal,
  ) {
    return _spine_physics_constraint_data_set_strength_global(
      self,
      strengthGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_strength_globalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Bool)>>('spine_physics_constraint_data_set_strength_global');
  late final _spine_physics_constraint_data_set_strength_global =
      _spine_physics_constraint_data_set_strength_globalPtr
          .asFunction<void Function(spine_physics_constraint_data, bool)>();

  bool spine_physics_constraint_data_get_damping_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_damping_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_damping_globalPtr = _lookup<
          ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_damping_global');
  late final _spine_physics_constraint_data_get_damping_global =
      _spine_physics_constraint_data_get_damping_globalPtr
          .asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_damping_global(
    spine_physics_constraint_data self,
    bool dampingGlobal,
  ) {
    return _spine_physics_constraint_data_set_damping_global(
      self,
      dampingGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_damping_globalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Bool)>>('spine_physics_constraint_data_set_damping_global');
  late final _spine_physics_constraint_data_set_damping_global =
      _spine_physics_constraint_data_set_damping_globalPtr
          .asFunction<void Function(spine_physics_constraint_data, bool)>();

  bool spine_physics_constraint_data_get_mass_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_mass_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_mass_globalPtr = _lookup<
          ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_mass_global');
  late final _spine_physics_constraint_data_get_mass_global =
      _spine_physics_constraint_data_get_mass_globalPtr
          .asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_mass_global(
    spine_physics_constraint_data self,
    bool massGlobal,
  ) {
    return _spine_physics_constraint_data_set_mass_global(
      self,
      massGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_mass_globalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Bool)>>('spine_physics_constraint_data_set_mass_global');
  late final _spine_physics_constraint_data_set_mass_global =
      _spine_physics_constraint_data_set_mass_globalPtr
          .asFunction<void Function(spine_physics_constraint_data, bool)>();

  bool spine_physics_constraint_data_get_wind_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_wind_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_wind_globalPtr = _lookup<
          ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_wind_global');
  late final _spine_physics_constraint_data_get_wind_global =
      _spine_physics_constraint_data_get_wind_globalPtr
          .asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_wind_global(
    spine_physics_constraint_data self,
    bool windGlobal,
  ) {
    return _spine_physics_constraint_data_set_wind_global(
      self,
      windGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_wind_globalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Bool)>>('spine_physics_constraint_data_set_wind_global');
  late final _spine_physics_constraint_data_set_wind_global =
      _spine_physics_constraint_data_set_wind_globalPtr
          .asFunction<void Function(spine_physics_constraint_data, bool)>();

  bool spine_physics_constraint_data_get_gravity_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_gravity_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_gravity_globalPtr = _lookup<
          ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_gravity_global');
  late final _spine_physics_constraint_data_get_gravity_global =
      _spine_physics_constraint_data_get_gravity_globalPtr
          .asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_gravity_global(
    spine_physics_constraint_data self,
    bool gravityGlobal,
  ) {
    return _spine_physics_constraint_data_set_gravity_global(
      self,
      gravityGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_gravity_globalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Bool)>>('spine_physics_constraint_data_set_gravity_global');
  late final _spine_physics_constraint_data_set_gravity_global =
      _spine_physics_constraint_data_set_gravity_globalPtr
          .asFunction<void Function(spine_physics_constraint_data, bool)>();

  bool spine_physics_constraint_data_get_mix_global(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_mix_global(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_mix_globalPtr = _lookup<
          ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_mix_global');
  late final _spine_physics_constraint_data_get_mix_global =
      _spine_physics_constraint_data_get_mix_globalPtr
          .asFunction<bool Function(spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_mix_global(
    spine_physics_constraint_data self,
    bool mixGlobal,
  ) {
    return _spine_physics_constraint_data_set_mix_global(
      self,
      mixGlobal,
    );
  }

  late final _spine_physics_constraint_data_set_mix_globalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Bool)>>('spine_physics_constraint_data_set_mix_global');
  late final _spine_physics_constraint_data_set_mix_global =
      _spine_physics_constraint_data_set_mix_globalPtr
          .asFunction<void Function(spine_physics_constraint_data, bool)>();

  ffi.Pointer<ffi.Char> spine_physics_constraint_data_get_name(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_name(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_namePtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_name');
  late final _spine_physics_constraint_data_get_name =
      _spine_physics_constraint_data_get_namePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(spine_physics_constraint_data)>();

  bool spine_physics_constraint_data_get_skin_required(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_skin_required(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_skin_requiredPtr = _lookup<
          ffi.NativeFunction<ffi.Bool Function(spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_skin_required');
  late final _spine_physics_constraint_data_get_skin_required =
      _spine_physics_constraint_data_get_skin_requiredPtr
          .asFunction<bool Function(spine_physics_constraint_data)>();

  spine_physics_constraint_pose spine_physics_constraint_data_get_setup_pose(
    spine_physics_constraint_data self,
  ) {
    return _spine_physics_constraint_data_get_setup_pose(
      self,
    );
  }

  late final _spine_physics_constraint_data_get_setup_posePtr = _lookup<
          ffi.NativeFunction<
              spine_physics_constraint_pose Function(
                  spine_physics_constraint_data)>>(
      'spine_physics_constraint_data_get_setup_pose');
  late final _spine_physics_constraint_data_get_setup_pose =
      _spine_physics_constraint_data_get_setup_posePtr.asFunction<
          spine_physics_constraint_pose Function(
              spine_physics_constraint_data)>();

  void spine_physics_constraint_data_set_skin_required(
    spine_physics_constraint_data self,
    bool skinRequired,
  ) {
    return _spine_physics_constraint_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_physics_constraint_data_set_skin_requiredPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_data,
              ffi.Bool)>>('spine_physics_constraint_data_set_skin_required');
  late final _spine_physics_constraint_data_set_skin_required =
      _spine_physics_constraint_data_set_skin_requiredPtr
          .asFunction<void Function(spine_physics_constraint_data, bool)>();

  spine_rtti spine_physics_constraint_data_rtti() {
    return _spine_physics_constraint_data_rtti();
  }

  late final _spine_physics_constraint_data_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_physics_constraint_data_rtti');
  late final _spine_physics_constraint_data_rtti =
      _spine_physics_constraint_data_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_physics_constraint_gravity_timeline
      spine_physics_constraint_gravity_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_gravity_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_physics_constraint_gravity_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_physics_constraint_gravity_timeline_create');
  late final _spine_physics_constraint_gravity_timeline_create =
      _spine_physics_constraint_gravity_timeline_createPtr.asFunction<
          spine_physics_constraint_gravity_timeline Function(int, int, int)>();

  void spine_physics_constraint_gravity_timeline_dispose(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_gravity_timeline)>>(
      'spine_physics_constraint_gravity_timeline_dispose');
  late final _spine_physics_constraint_gravity_timeline_dispose =
      _spine_physics_constraint_gravity_timeline_disposePtr.asFunction<
          void Function(spine_physics_constraint_gravity_timeline)>();

  spine_rtti spine_physics_constraint_gravity_timeline_get_rtti(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_physics_constraint_gravity_timeline)>>(
      'spine_physics_constraint_gravity_timeline_get_rtti');
  late final _spine_physics_constraint_gravity_timeline_get_rtti =
      _spine_physics_constraint_gravity_timeline_get_rttiPtr.asFunction<
          spine_rtti Function(spine_physics_constraint_gravity_timeline)>();

  void spine_physics_constraint_gravity_timeline_apply(
    spine_physics_constraint_gravity_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_gravity_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_gravity_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_gravity_timeline_apply');
  late final _spine_physics_constraint_gravity_timeline_apply =
      _spine_physics_constraint_gravity_timeline_applyPtr.asFunction<
          void Function(
              spine_physics_constraint_gravity_timeline,
              spine_skeleton,
              double,
              double,
              spine_array_event,
              double,
              int,
              int,
              bool)>();

  void spine_physics_constraint_gravity_timeline_set_frame(
    spine_physics_constraint_gravity_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_gravity_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_set_framePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_gravity_timeline,
                  ffi.Size, ffi.Float, ffi.Float)>>(
      'spine_physics_constraint_gravity_timeline_set_frame');
  late final _spine_physics_constraint_gravity_timeline_set_frame =
      _spine_physics_constraint_gravity_timeline_set_framePtr.asFunction<
          void Function(spine_physics_constraint_gravity_timeline, int, double,
              double)>();

  double spine_physics_constraint_gravity_timeline_get_curve_value(
    spine_physics_constraint_gravity_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_curve_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_gravity_timeline, ffi.Float)>>(
          'spine_physics_constraint_gravity_timeline_get_curve_value');
  late final _spine_physics_constraint_gravity_timeline_get_curve_value =
      _spine_physics_constraint_gravity_timeline_get_curve_valuePtr.asFunction<
          double Function(spine_physics_constraint_gravity_timeline, double)>();

  double spine_physics_constraint_gravity_timeline_get_relative_value(
    spine_physics_constraint_gravity_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_relative_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_gravity_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_gravity_timeline_get_relative_value');
  late final _spine_physics_constraint_gravity_timeline_get_relative_value =
      _spine_physics_constraint_gravity_timeline_get_relative_valuePtr
          .asFunction<
              double Function(spine_physics_constraint_gravity_timeline, double,
                  double, int, double, double)>();

  double spine_physics_constraint_gravity_timeline_get_absolute_value_1(
    spine_physics_constraint_gravity_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_absolute_value_1Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_gravity_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_gravity_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_gravity_timeline_get_absolute_value_1 =
      _spine_physics_constraint_gravity_timeline_get_absolute_value_1Ptr
          .asFunction<
              double Function(spine_physics_constraint_gravity_timeline, double,
                  double, int, double, double)>();

  double spine_physics_constraint_gravity_timeline_get_absolute_value_2(
    spine_physics_constraint_gravity_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_absolute_value_2Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_gravity_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_gravity_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_gravity_timeline_get_absolute_value_2 =
      _spine_physics_constraint_gravity_timeline_get_absolute_value_2Ptr
          .asFunction<
              double Function(spine_physics_constraint_gravity_timeline, double,
                  double, int, double, double, double)>();

  double spine_physics_constraint_gravity_timeline_get_scale_value(
    spine_physics_constraint_gravity_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_scale_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_gravity_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_gravity_timeline_get_scale_value');
  late final _spine_physics_constraint_gravity_timeline_get_scale_value =
      _spine_physics_constraint_gravity_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_gravity_timeline, double,
              double, int, int, double, double)>();

  void spine_physics_constraint_gravity_timeline_set_linear(
    spine_physics_constraint_gravity_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_gravity_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_set_linearPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  spine_physics_constraint_gravity_timeline, ffi.Size)>>(
      'spine_physics_constraint_gravity_timeline_set_linear');
  late final _spine_physics_constraint_gravity_timeline_set_linear =
      _spine_physics_constraint_gravity_timeline_set_linearPtr.asFunction<
          void Function(spine_physics_constraint_gravity_timeline, int)>();

  void spine_physics_constraint_gravity_timeline_set_stepped(
    spine_physics_constraint_gravity_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_gravity_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_set_steppedPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_gravity_timeline, ffi.Size)>>(
          'spine_physics_constraint_gravity_timeline_set_stepped');
  late final _spine_physics_constraint_gravity_timeline_set_stepped =
      _spine_physics_constraint_gravity_timeline_set_steppedPtr.asFunction<
          void Function(spine_physics_constraint_gravity_timeline, int)>();

  void spine_physics_constraint_gravity_timeline_set_bezier(
    spine_physics_constraint_gravity_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_gravity_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_set_bezierPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  spine_physics_constraint_gravity_timeline,
                  ffi.Size,
                  ffi.Size,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float)>>(
      'spine_physics_constraint_gravity_timeline_set_bezier');
  late final _spine_physics_constraint_gravity_timeline_set_bezier =
      _spine_physics_constraint_gravity_timeline_set_bezierPtr.asFunction<
          void Function(
              spine_physics_constraint_gravity_timeline,
              int,
              int,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double)>();

  double spine_physics_constraint_gravity_timeline_get_bezier_value(
    spine_physics_constraint_gravity_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_bezier_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_gravity_timeline,
                      ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_physics_constraint_gravity_timeline_get_bezier_value');
  late final _spine_physics_constraint_gravity_timeline_get_bezier_value =
      _spine_physics_constraint_gravity_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_physics_constraint_gravity_timeline, double,
              int, int, int)>();

  spine_array_float spine_physics_constraint_gravity_timeline_get_curves(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_physics_constraint_gravity_timeline)>>(
      'spine_physics_constraint_gravity_timeline_get_curves');
  late final _spine_physics_constraint_gravity_timeline_get_curves =
      _spine_physics_constraint_gravity_timeline_get_curvesPtr.asFunction<
          spine_array_float Function(
              spine_physics_constraint_gravity_timeline)>();

  int spine_physics_constraint_gravity_timeline_get_frame_entries(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_frame_entriesPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(
                      spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_get_frame_entries');
  late final _spine_physics_constraint_gravity_timeline_get_frame_entries =
      _spine_physics_constraint_gravity_timeline_get_frame_entriesPtr
          .asFunction<
              int Function(spine_physics_constraint_gravity_timeline)>();

  int spine_physics_constraint_gravity_timeline_get_frame_count(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_frame_countPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(
                      spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_get_frame_count');
  late final _spine_physics_constraint_gravity_timeline_get_frame_count =
      _spine_physics_constraint_gravity_timeline_get_frame_countPtr.asFunction<
          int Function(spine_physics_constraint_gravity_timeline)>();

  spine_array_float spine_physics_constraint_gravity_timeline_get_frames(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_physics_constraint_gravity_timeline)>>(
      'spine_physics_constraint_gravity_timeline_get_frames');
  late final _spine_physics_constraint_gravity_timeline_get_frames =
      _spine_physics_constraint_gravity_timeline_get_framesPtr.asFunction<
          spine_array_float Function(
              spine_physics_constraint_gravity_timeline)>();

  double spine_physics_constraint_gravity_timeline_get_duration(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_durationPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_get_duration');
  late final _spine_physics_constraint_gravity_timeline_get_duration =
      _spine_physics_constraint_gravity_timeline_get_durationPtr.asFunction<
          double Function(spine_physics_constraint_gravity_timeline)>();

  spine_array_property_id
      spine_physics_constraint_gravity_timeline_get_property_ids(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_property_idsPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_array_property_id Function(
                      spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_get_property_ids');
  late final _spine_physics_constraint_gravity_timeline_get_property_ids =
      _spine_physics_constraint_gravity_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(
              spine_physics_constraint_gravity_timeline)>();

  int spine_physics_constraint_gravity_timeline_get_constraint_index(
    spine_physics_constraint_gravity_timeline self,
  ) {
    return _spine_physics_constraint_gravity_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_get_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(spine_physics_constraint_gravity_timeline)>>(
          'spine_physics_constraint_gravity_timeline_get_constraint_index');
  late final _spine_physics_constraint_gravity_timeline_get_constraint_index =
      _spine_physics_constraint_gravity_timeline_get_constraint_indexPtr
          .asFunction<
              int Function(spine_physics_constraint_gravity_timeline)>();

  void spine_physics_constraint_gravity_timeline_set_constraint_index(
    spine_physics_constraint_gravity_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_gravity_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_gravity_timeline_set_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_gravity_timeline, ffi.Int)>>(
          'spine_physics_constraint_gravity_timeline_set_constraint_index');
  late final _spine_physics_constraint_gravity_timeline_set_constraint_index =
      _spine_physics_constraint_gravity_timeline_set_constraint_indexPtr
          .asFunction<
              void Function(spine_physics_constraint_gravity_timeline, int)>();

  spine_rtti spine_physics_constraint_gravity_timeline_rtti() {
    return _spine_physics_constraint_gravity_timeline_rtti();
  }

  late final _spine_physics_constraint_gravity_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_physics_constraint_gravity_timeline_rtti');
  late final _spine_physics_constraint_gravity_timeline_rtti =
      _spine_physics_constraint_gravity_timeline_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_physics_constraint_inertia_timeline
      spine_physics_constraint_inertia_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_inertia_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_physics_constraint_inertia_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_physics_constraint_inertia_timeline_create');
  late final _spine_physics_constraint_inertia_timeline_create =
      _spine_physics_constraint_inertia_timeline_createPtr.asFunction<
          spine_physics_constraint_inertia_timeline Function(int, int, int)>();

  void spine_physics_constraint_inertia_timeline_dispose(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_inertia_timeline)>>(
      'spine_physics_constraint_inertia_timeline_dispose');
  late final _spine_physics_constraint_inertia_timeline_dispose =
      _spine_physics_constraint_inertia_timeline_disposePtr.asFunction<
          void Function(spine_physics_constraint_inertia_timeline)>();

  spine_rtti spine_physics_constraint_inertia_timeline_get_rtti(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_physics_constraint_inertia_timeline)>>(
      'spine_physics_constraint_inertia_timeline_get_rtti');
  late final _spine_physics_constraint_inertia_timeline_get_rtti =
      _spine_physics_constraint_inertia_timeline_get_rttiPtr.asFunction<
          spine_rtti Function(spine_physics_constraint_inertia_timeline)>();

  void spine_physics_constraint_inertia_timeline_apply(
    spine_physics_constraint_inertia_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_inertia_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_inertia_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_inertia_timeline_apply');
  late final _spine_physics_constraint_inertia_timeline_apply =
      _spine_physics_constraint_inertia_timeline_applyPtr.asFunction<
          void Function(
              spine_physics_constraint_inertia_timeline,
              spine_skeleton,
              double,
              double,
              spine_array_event,
              double,
              int,
              int,
              bool)>();

  void spine_physics_constraint_inertia_timeline_set_frame(
    spine_physics_constraint_inertia_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_inertia_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_set_framePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_inertia_timeline,
                  ffi.Size, ffi.Float, ffi.Float)>>(
      'spine_physics_constraint_inertia_timeline_set_frame');
  late final _spine_physics_constraint_inertia_timeline_set_frame =
      _spine_physics_constraint_inertia_timeline_set_framePtr.asFunction<
          void Function(spine_physics_constraint_inertia_timeline, int, double,
              double)>();

  double spine_physics_constraint_inertia_timeline_get_curve_value(
    spine_physics_constraint_inertia_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_curve_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_inertia_timeline, ffi.Float)>>(
          'spine_physics_constraint_inertia_timeline_get_curve_value');
  late final _spine_physics_constraint_inertia_timeline_get_curve_value =
      _spine_physics_constraint_inertia_timeline_get_curve_valuePtr.asFunction<
          double Function(spine_physics_constraint_inertia_timeline, double)>();

  double spine_physics_constraint_inertia_timeline_get_relative_value(
    spine_physics_constraint_inertia_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_relative_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_inertia_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_inertia_timeline_get_relative_value');
  late final _spine_physics_constraint_inertia_timeline_get_relative_value =
      _spine_physics_constraint_inertia_timeline_get_relative_valuePtr
          .asFunction<
              double Function(spine_physics_constraint_inertia_timeline, double,
                  double, int, double, double)>();

  double spine_physics_constraint_inertia_timeline_get_absolute_value_1(
    spine_physics_constraint_inertia_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_absolute_value_1Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_inertia_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_inertia_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_inertia_timeline_get_absolute_value_1 =
      _spine_physics_constraint_inertia_timeline_get_absolute_value_1Ptr
          .asFunction<
              double Function(spine_physics_constraint_inertia_timeline, double,
                  double, int, double, double)>();

  double spine_physics_constraint_inertia_timeline_get_absolute_value_2(
    spine_physics_constraint_inertia_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_absolute_value_2Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_inertia_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_inertia_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_inertia_timeline_get_absolute_value_2 =
      _spine_physics_constraint_inertia_timeline_get_absolute_value_2Ptr
          .asFunction<
              double Function(spine_physics_constraint_inertia_timeline, double,
                  double, int, double, double, double)>();

  double spine_physics_constraint_inertia_timeline_get_scale_value(
    spine_physics_constraint_inertia_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_scale_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_inertia_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_inertia_timeline_get_scale_value');
  late final _spine_physics_constraint_inertia_timeline_get_scale_value =
      _spine_physics_constraint_inertia_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_inertia_timeline, double,
              double, int, int, double, double)>();

  void spine_physics_constraint_inertia_timeline_set_linear(
    spine_physics_constraint_inertia_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_inertia_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_set_linearPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  spine_physics_constraint_inertia_timeline, ffi.Size)>>(
      'spine_physics_constraint_inertia_timeline_set_linear');
  late final _spine_physics_constraint_inertia_timeline_set_linear =
      _spine_physics_constraint_inertia_timeline_set_linearPtr.asFunction<
          void Function(spine_physics_constraint_inertia_timeline, int)>();

  void spine_physics_constraint_inertia_timeline_set_stepped(
    spine_physics_constraint_inertia_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_inertia_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_set_steppedPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_inertia_timeline, ffi.Size)>>(
          'spine_physics_constraint_inertia_timeline_set_stepped');
  late final _spine_physics_constraint_inertia_timeline_set_stepped =
      _spine_physics_constraint_inertia_timeline_set_steppedPtr.asFunction<
          void Function(spine_physics_constraint_inertia_timeline, int)>();

  void spine_physics_constraint_inertia_timeline_set_bezier(
    spine_physics_constraint_inertia_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_inertia_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_set_bezierPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  spine_physics_constraint_inertia_timeline,
                  ffi.Size,
                  ffi.Size,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float,
                  ffi.Float)>>(
      'spine_physics_constraint_inertia_timeline_set_bezier');
  late final _spine_physics_constraint_inertia_timeline_set_bezier =
      _spine_physics_constraint_inertia_timeline_set_bezierPtr.asFunction<
          void Function(
              spine_physics_constraint_inertia_timeline,
              int,
              int,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double)>();

  double spine_physics_constraint_inertia_timeline_get_bezier_value(
    spine_physics_constraint_inertia_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_bezier_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_inertia_timeline,
                      ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_physics_constraint_inertia_timeline_get_bezier_value');
  late final _spine_physics_constraint_inertia_timeline_get_bezier_value =
      _spine_physics_constraint_inertia_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_physics_constraint_inertia_timeline, double,
              int, int, int)>();

  spine_array_float spine_physics_constraint_inertia_timeline_get_curves(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_physics_constraint_inertia_timeline)>>(
      'spine_physics_constraint_inertia_timeline_get_curves');
  late final _spine_physics_constraint_inertia_timeline_get_curves =
      _spine_physics_constraint_inertia_timeline_get_curvesPtr.asFunction<
          spine_array_float Function(
              spine_physics_constraint_inertia_timeline)>();

  int spine_physics_constraint_inertia_timeline_get_frame_entries(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_frame_entriesPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(
                      spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_get_frame_entries');
  late final _spine_physics_constraint_inertia_timeline_get_frame_entries =
      _spine_physics_constraint_inertia_timeline_get_frame_entriesPtr
          .asFunction<
              int Function(spine_physics_constraint_inertia_timeline)>();

  int spine_physics_constraint_inertia_timeline_get_frame_count(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_frame_countPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(
                      spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_get_frame_count');
  late final _spine_physics_constraint_inertia_timeline_get_frame_count =
      _spine_physics_constraint_inertia_timeline_get_frame_countPtr.asFunction<
          int Function(spine_physics_constraint_inertia_timeline)>();

  spine_array_float spine_physics_constraint_inertia_timeline_get_frames(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_physics_constraint_inertia_timeline)>>(
      'spine_physics_constraint_inertia_timeline_get_frames');
  late final _spine_physics_constraint_inertia_timeline_get_frames =
      _spine_physics_constraint_inertia_timeline_get_framesPtr.asFunction<
          spine_array_float Function(
              spine_physics_constraint_inertia_timeline)>();

  double spine_physics_constraint_inertia_timeline_get_duration(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_durationPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_get_duration');
  late final _spine_physics_constraint_inertia_timeline_get_duration =
      _spine_physics_constraint_inertia_timeline_get_durationPtr.asFunction<
          double Function(spine_physics_constraint_inertia_timeline)>();

  spine_array_property_id
      spine_physics_constraint_inertia_timeline_get_property_ids(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_property_idsPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_array_property_id Function(
                      spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_get_property_ids');
  late final _spine_physics_constraint_inertia_timeline_get_property_ids =
      _spine_physics_constraint_inertia_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(
              spine_physics_constraint_inertia_timeline)>();

  int spine_physics_constraint_inertia_timeline_get_constraint_index(
    spine_physics_constraint_inertia_timeline self,
  ) {
    return _spine_physics_constraint_inertia_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_get_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(spine_physics_constraint_inertia_timeline)>>(
          'spine_physics_constraint_inertia_timeline_get_constraint_index');
  late final _spine_physics_constraint_inertia_timeline_get_constraint_index =
      _spine_physics_constraint_inertia_timeline_get_constraint_indexPtr
          .asFunction<
              int Function(spine_physics_constraint_inertia_timeline)>();

  void spine_physics_constraint_inertia_timeline_set_constraint_index(
    spine_physics_constraint_inertia_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_inertia_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_inertia_timeline_set_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_inertia_timeline, ffi.Int)>>(
          'spine_physics_constraint_inertia_timeline_set_constraint_index');
  late final _spine_physics_constraint_inertia_timeline_set_constraint_index =
      _spine_physics_constraint_inertia_timeline_set_constraint_indexPtr
          .asFunction<
              void Function(spine_physics_constraint_inertia_timeline, int)>();

  spine_rtti spine_physics_constraint_inertia_timeline_rtti() {
    return _spine_physics_constraint_inertia_timeline_rtti();
  }

  late final _spine_physics_constraint_inertia_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_physics_constraint_inertia_timeline_rtti');
  late final _spine_physics_constraint_inertia_timeline_rtti =
      _spine_physics_constraint_inertia_timeline_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_physics_constraint_mass_timeline
      spine_physics_constraint_mass_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_mass_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_mass_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_physics_constraint_mass_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_physics_constraint_mass_timeline_create');
  late final _spine_physics_constraint_mass_timeline_create =
      _spine_physics_constraint_mass_timeline_createPtr.asFunction<
          spine_physics_constraint_mass_timeline Function(int, int, int)>();

  void spine_physics_constraint_mass_timeline_dispose(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_mass_timeline)>>(
      'spine_physics_constraint_mass_timeline_dispose');
  late final _spine_physics_constraint_mass_timeline_dispose =
      _spine_physics_constraint_mass_timeline_disposePtr
          .asFunction<void Function(spine_physics_constraint_mass_timeline)>();

  spine_rtti spine_physics_constraint_mass_timeline_get_rtti(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_physics_constraint_mass_timeline)>>(
      'spine_physics_constraint_mass_timeline_get_rtti');
  late final _spine_physics_constraint_mass_timeline_get_rtti =
      _spine_physics_constraint_mass_timeline_get_rttiPtr.asFunction<
          spine_rtti Function(spine_physics_constraint_mass_timeline)>();

  void spine_physics_constraint_mass_timeline_apply(
    spine_physics_constraint_mass_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_mass_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_mass_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_mass_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_mass_timeline_apply');
  late final _spine_physics_constraint_mass_timeline_apply =
      _spine_physics_constraint_mass_timeline_applyPtr.asFunction<
          void Function(spine_physics_constraint_mass_timeline, spine_skeleton,
              double, double, spine_array_event, double, int, int, bool)>();

  void spine_physics_constraint_mass_timeline_set_frame(
    spine_physics_constraint_mass_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_mass_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_mass_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_mass_timeline,
              ffi.Size,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_mass_timeline_set_frame');
  late final _spine_physics_constraint_mass_timeline_set_frame =
      _spine_physics_constraint_mass_timeline_set_framePtr.asFunction<
          void Function(
              spine_physics_constraint_mass_timeline, int, double, double)>();

  double spine_physics_constraint_mass_timeline_get_curve_value(
    spine_physics_constraint_mass_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_mass_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_curve_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_mass_timeline, ffi.Float)>>(
          'spine_physics_constraint_mass_timeline_get_curve_value');
  late final _spine_physics_constraint_mass_timeline_get_curve_value =
      _spine_physics_constraint_mass_timeline_get_curve_valuePtr.asFunction<
          double Function(spine_physics_constraint_mass_timeline, double)>();

  double spine_physics_constraint_mass_timeline_get_relative_value(
    spine_physics_constraint_mass_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_mass_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_relative_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_mass_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_mass_timeline_get_relative_value');
  late final _spine_physics_constraint_mass_timeline_get_relative_value =
      _spine_physics_constraint_mass_timeline_get_relative_valuePtr.asFunction<
          double Function(spine_physics_constraint_mass_timeline, double,
              double, int, double, double)>();

  double spine_physics_constraint_mass_timeline_get_absolute_value_1(
    spine_physics_constraint_mass_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_mass_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_absolute_value_1Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_mass_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_mass_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_mass_timeline_get_absolute_value_1 =
      _spine_physics_constraint_mass_timeline_get_absolute_value_1Ptr
          .asFunction<
              double Function(spine_physics_constraint_mass_timeline, double,
                  double, int, double, double)>();

  double spine_physics_constraint_mass_timeline_get_absolute_value_2(
    spine_physics_constraint_mass_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_mass_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_absolute_value_2Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_mass_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_mass_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_mass_timeline_get_absolute_value_2 =
      _spine_physics_constraint_mass_timeline_get_absolute_value_2Ptr
          .asFunction<
              double Function(spine_physics_constraint_mass_timeline, double,
                  double, int, double, double, double)>();

  double spine_physics_constraint_mass_timeline_get_scale_value(
    spine_physics_constraint_mass_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_mass_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_scale_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_mass_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_mass_timeline_get_scale_value');
  late final _spine_physics_constraint_mass_timeline_get_scale_value =
      _spine_physics_constraint_mass_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_mass_timeline, double,
              double, int, int, double, double)>();

  void spine_physics_constraint_mass_timeline_set_linear(
    spine_physics_constraint_mass_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_mass_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_mass_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_mass_timeline,
              ffi.Size)>>('spine_physics_constraint_mass_timeline_set_linear');
  late final _spine_physics_constraint_mass_timeline_set_linear =
      _spine_physics_constraint_mass_timeline_set_linearPtr.asFunction<
          void Function(spine_physics_constraint_mass_timeline, int)>();

  void spine_physics_constraint_mass_timeline_set_stepped(
    spine_physics_constraint_mass_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_mass_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_mass_timeline_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_mass_timeline,
              ffi.Size)>>('spine_physics_constraint_mass_timeline_set_stepped');
  late final _spine_physics_constraint_mass_timeline_set_stepped =
      _spine_physics_constraint_mass_timeline_set_steppedPtr.asFunction<
          void Function(spine_physics_constraint_mass_timeline, int)>();

  void spine_physics_constraint_mass_timeline_set_bezier(
    spine_physics_constraint_mass_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_mass_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_mass_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_mass_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_mass_timeline_set_bezier');
  late final _spine_physics_constraint_mass_timeline_set_bezier =
      _spine_physics_constraint_mass_timeline_set_bezierPtr.asFunction<
          void Function(
              spine_physics_constraint_mass_timeline,
              int,
              int,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double)>();

  double spine_physics_constraint_mass_timeline_get_bezier_value(
    spine_physics_constraint_mass_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_mass_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_bezier_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_mass_timeline,
                      ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_physics_constraint_mass_timeline_get_bezier_value');
  late final _spine_physics_constraint_mass_timeline_get_bezier_value =
      _spine_physics_constraint_mass_timeline_get_bezier_valuePtr.asFunction<
          double Function(
              spine_physics_constraint_mass_timeline, double, int, int, int)>();

  spine_array_float spine_physics_constraint_mass_timeline_get_curves(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_physics_constraint_mass_timeline)>>(
      'spine_physics_constraint_mass_timeline_get_curves');
  late final _spine_physics_constraint_mass_timeline_get_curves =
      _spine_physics_constraint_mass_timeline_get_curvesPtr.asFunction<
          spine_array_float Function(spine_physics_constraint_mass_timeline)>();

  int spine_physics_constraint_mass_timeline_get_frame_entries(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_frame_entriesPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_get_frame_entries');
  late final _spine_physics_constraint_mass_timeline_get_frame_entries =
      _spine_physics_constraint_mass_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_mass_timeline)>();

  int spine_physics_constraint_mass_timeline_get_frame_count(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_frame_countPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_get_frame_count');
  late final _spine_physics_constraint_mass_timeline_get_frame_count =
      _spine_physics_constraint_mass_timeline_get_frame_countPtr
          .asFunction<int Function(spine_physics_constraint_mass_timeline)>();

  spine_array_float spine_physics_constraint_mass_timeline_get_frames(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_physics_constraint_mass_timeline)>>(
      'spine_physics_constraint_mass_timeline_get_frames');
  late final _spine_physics_constraint_mass_timeline_get_frames =
      _spine_physics_constraint_mass_timeline_get_framesPtr.asFunction<
          spine_array_float Function(spine_physics_constraint_mass_timeline)>();

  double spine_physics_constraint_mass_timeline_get_duration(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<
              ffi.Float Function(spine_physics_constraint_mass_timeline)>>(
      'spine_physics_constraint_mass_timeline_get_duration');
  late final _spine_physics_constraint_mass_timeline_get_duration =
      _spine_physics_constraint_mass_timeline_get_durationPtr.asFunction<
          double Function(spine_physics_constraint_mass_timeline)>();

  spine_array_property_id
      spine_physics_constraint_mass_timeline_get_property_ids(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_property_idsPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_array_property_id Function(
                      spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_get_property_ids');
  late final _spine_physics_constraint_mass_timeline_get_property_ids =
      _spine_physics_constraint_mass_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(
              spine_physics_constraint_mass_timeline)>();

  int spine_physics_constraint_mass_timeline_get_constraint_index(
    spine_physics_constraint_mass_timeline self,
  ) {
    return _spine_physics_constraint_mass_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_mass_timeline_get_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(spine_physics_constraint_mass_timeline)>>(
          'spine_physics_constraint_mass_timeline_get_constraint_index');
  late final _spine_physics_constraint_mass_timeline_get_constraint_index =
      _spine_physics_constraint_mass_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_mass_timeline)>();

  void spine_physics_constraint_mass_timeline_set_constraint_index(
    spine_physics_constraint_mass_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_mass_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_mass_timeline_set_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_mass_timeline, ffi.Int)>>(
          'spine_physics_constraint_mass_timeline_set_constraint_index');
  late final _spine_physics_constraint_mass_timeline_set_constraint_index =
      _spine_physics_constraint_mass_timeline_set_constraint_indexPtr
          .asFunction<
              void Function(spine_physics_constraint_mass_timeline, int)>();

  spine_rtti spine_physics_constraint_mass_timeline_rtti() {
    return _spine_physics_constraint_mass_timeline_rtti();
  }

  late final _spine_physics_constraint_mass_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_physics_constraint_mass_timeline_rtti');
  late final _spine_physics_constraint_mass_timeline_rtti =
      _spine_physics_constraint_mass_timeline_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_physics_constraint_mix_timeline
      spine_physics_constraint_mix_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_mix_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_mix_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_physics_constraint_mix_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_physics_constraint_mix_timeline_create');
  late final _spine_physics_constraint_mix_timeline_create =
      _spine_physics_constraint_mix_timeline_createPtr.asFunction<
          spine_physics_constraint_mix_timeline Function(int, int, int)>();

  void spine_physics_constraint_mix_timeline_dispose(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_mix_timeline)>>(
      'spine_physics_constraint_mix_timeline_dispose');
  late final _spine_physics_constraint_mix_timeline_dispose =
      _spine_physics_constraint_mix_timeline_disposePtr
          .asFunction<void Function(spine_physics_constraint_mix_timeline)>();

  spine_rtti spine_physics_constraint_mix_timeline_get_rtti(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_physics_constraint_mix_timeline)>>(
      'spine_physics_constraint_mix_timeline_get_rtti');
  late final _spine_physics_constraint_mix_timeline_get_rtti =
      _spine_physics_constraint_mix_timeline_get_rttiPtr.asFunction<
          spine_rtti Function(spine_physics_constraint_mix_timeline)>();

  void spine_physics_constraint_mix_timeline_apply(
    spine_physics_constraint_mix_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_mix_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_mix_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_mix_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_mix_timeline_apply');
  late final _spine_physics_constraint_mix_timeline_apply =
      _spine_physics_constraint_mix_timeline_applyPtr.asFunction<
          void Function(spine_physics_constraint_mix_timeline, spine_skeleton,
              double, double, spine_array_event, double, int, int, bool)>();

  void spine_physics_constraint_mix_timeline_set_frame(
    spine_physics_constraint_mix_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_mix_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_mix_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_mix_timeline,
              ffi.Size,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_mix_timeline_set_frame');
  late final _spine_physics_constraint_mix_timeline_set_frame =
      _spine_physics_constraint_mix_timeline_set_framePtr.asFunction<
          void Function(
              spine_physics_constraint_mix_timeline, int, double, double)>();

  double spine_physics_constraint_mix_timeline_get_curve_value(
    spine_physics_constraint_mix_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_mix_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_curve_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_mix_timeline, ffi.Float)>>(
          'spine_physics_constraint_mix_timeline_get_curve_value');
  late final _spine_physics_constraint_mix_timeline_get_curve_value =
      _spine_physics_constraint_mix_timeline_get_curve_valuePtr.asFunction<
          double Function(spine_physics_constraint_mix_timeline, double)>();

  double spine_physics_constraint_mix_timeline_get_relative_value(
    spine_physics_constraint_mix_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_mix_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_relative_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_mix_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_mix_timeline_get_relative_value');
  late final _spine_physics_constraint_mix_timeline_get_relative_value =
      _spine_physics_constraint_mix_timeline_get_relative_valuePtr.asFunction<
          double Function(spine_physics_constraint_mix_timeline, double, double,
              int, double, double)>();

  double spine_physics_constraint_mix_timeline_get_absolute_value_1(
    spine_physics_constraint_mix_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_mix_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_absolute_value_1Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_mix_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_mix_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_mix_timeline_get_absolute_value_1 =
      _spine_physics_constraint_mix_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(spine_physics_constraint_mix_timeline, double, double,
              int, double, double)>();

  double spine_physics_constraint_mix_timeline_get_absolute_value_2(
    spine_physics_constraint_mix_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_mix_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_absolute_value_2Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_mix_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_mix_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_mix_timeline_get_absolute_value_2 =
      _spine_physics_constraint_mix_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_physics_constraint_mix_timeline, double, double,
              int, double, double, double)>();

  double spine_physics_constraint_mix_timeline_get_scale_value(
    spine_physics_constraint_mix_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_mix_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_scale_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_mix_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_mix_timeline_get_scale_value');
  late final _spine_physics_constraint_mix_timeline_get_scale_value =
      _spine_physics_constraint_mix_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_mix_timeline, double, double,
              int, int, double, double)>();

  void spine_physics_constraint_mix_timeline_set_linear(
    spine_physics_constraint_mix_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_mix_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_mix_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_mix_timeline,
              ffi.Size)>>('spine_physics_constraint_mix_timeline_set_linear');
  late final _spine_physics_constraint_mix_timeline_set_linear =
      _spine_physics_constraint_mix_timeline_set_linearPtr.asFunction<
          void Function(spine_physics_constraint_mix_timeline, int)>();

  void spine_physics_constraint_mix_timeline_set_stepped(
    spine_physics_constraint_mix_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_mix_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_mix_timeline_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_mix_timeline,
              ffi.Size)>>('spine_physics_constraint_mix_timeline_set_stepped');
  late final _spine_physics_constraint_mix_timeline_set_stepped =
      _spine_physics_constraint_mix_timeline_set_steppedPtr.asFunction<
          void Function(spine_physics_constraint_mix_timeline, int)>();

  void spine_physics_constraint_mix_timeline_set_bezier(
    spine_physics_constraint_mix_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_mix_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_mix_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_mix_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_mix_timeline_set_bezier');
  late final _spine_physics_constraint_mix_timeline_set_bezier =
      _spine_physics_constraint_mix_timeline_set_bezierPtr.asFunction<
          void Function(
              spine_physics_constraint_mix_timeline,
              int,
              int,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double)>();

  double spine_physics_constraint_mix_timeline_get_bezier_value(
    spine_physics_constraint_mix_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_mix_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_bezier_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_mix_timeline,
                      ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_physics_constraint_mix_timeline_get_bezier_value');
  late final _spine_physics_constraint_mix_timeline_get_bezier_value =
      _spine_physics_constraint_mix_timeline_get_bezier_valuePtr.asFunction<
          double Function(
              spine_physics_constraint_mix_timeline, double, int, int, int)>();

  spine_array_float spine_physics_constraint_mix_timeline_get_curves(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_physics_constraint_mix_timeline)>>(
      'spine_physics_constraint_mix_timeline_get_curves');
  late final _spine_physics_constraint_mix_timeline_get_curves =
      _spine_physics_constraint_mix_timeline_get_curvesPtr.asFunction<
          spine_array_float Function(spine_physics_constraint_mix_timeline)>();

  int spine_physics_constraint_mix_timeline_get_frame_entries(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_frame_entriesPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_get_frame_entries');
  late final _spine_physics_constraint_mix_timeline_get_frame_entries =
      _spine_physics_constraint_mix_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_mix_timeline)>();

  int spine_physics_constraint_mix_timeline_get_frame_count(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_frame_countPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_get_frame_count');
  late final _spine_physics_constraint_mix_timeline_get_frame_count =
      _spine_physics_constraint_mix_timeline_get_frame_countPtr
          .asFunction<int Function(spine_physics_constraint_mix_timeline)>();

  spine_array_float spine_physics_constraint_mix_timeline_get_frames(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_physics_constraint_mix_timeline)>>(
      'spine_physics_constraint_mix_timeline_get_frames');
  late final _spine_physics_constraint_mix_timeline_get_frames =
      _spine_physics_constraint_mix_timeline_get_framesPtr.asFunction<
          spine_array_float Function(spine_physics_constraint_mix_timeline)>();

  double spine_physics_constraint_mix_timeline_get_duration(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<
              ffi.Float Function(spine_physics_constraint_mix_timeline)>>(
      'spine_physics_constraint_mix_timeline_get_duration');
  late final _spine_physics_constraint_mix_timeline_get_duration =
      _spine_physics_constraint_mix_timeline_get_durationPtr
          .asFunction<double Function(spine_physics_constraint_mix_timeline)>();

  spine_array_property_id
      spine_physics_constraint_mix_timeline_get_property_ids(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_property_idsPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_array_property_id Function(
                      spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_get_property_ids');
  late final _spine_physics_constraint_mix_timeline_get_property_ids =
      _spine_physics_constraint_mix_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(
              spine_physics_constraint_mix_timeline)>();

  int spine_physics_constraint_mix_timeline_get_constraint_index(
    spine_physics_constraint_mix_timeline self,
  ) {
    return _spine_physics_constraint_mix_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_mix_timeline_get_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(spine_physics_constraint_mix_timeline)>>(
          'spine_physics_constraint_mix_timeline_get_constraint_index');
  late final _spine_physics_constraint_mix_timeline_get_constraint_index =
      _spine_physics_constraint_mix_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_mix_timeline)>();

  void spine_physics_constraint_mix_timeline_set_constraint_index(
    spine_physics_constraint_mix_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_mix_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_mix_timeline_set_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_mix_timeline, ffi.Int)>>(
          'spine_physics_constraint_mix_timeline_set_constraint_index');
  late final _spine_physics_constraint_mix_timeline_set_constraint_index =
      _spine_physics_constraint_mix_timeline_set_constraint_indexPtr.asFunction<
          void Function(spine_physics_constraint_mix_timeline, int)>();

  spine_rtti spine_physics_constraint_mix_timeline_rtti() {
    return _spine_physics_constraint_mix_timeline_rtti();
  }

  late final _spine_physics_constraint_mix_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_physics_constraint_mix_timeline_rtti');
  late final _spine_physics_constraint_mix_timeline_rtti =
      _spine_physics_constraint_mix_timeline_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_physics_constraint_pose spine_physics_constraint_pose_create() {
    return _spine_physics_constraint_pose_create();
  }

  late final _spine_physics_constraint_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_physics_constraint_pose Function()>>(
          'spine_physics_constraint_pose_create');
  late final _spine_physics_constraint_pose_create =
      _spine_physics_constraint_pose_createPtr
          .asFunction<spine_physics_constraint_pose Function()>();

  void spine_physics_constraint_pose_dispose(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_pose_disposePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_pose)>>(
      'spine_physics_constraint_pose_dispose');
  late final _spine_physics_constraint_pose_dispose =
      _spine_physics_constraint_pose_disposePtr
          .asFunction<void Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set(
    spine_physics_constraint_pose self,
    spine_physics_constraint_pose pose,
  ) {
    return _spine_physics_constraint_pose_set(
      self,
      pose,
    );
  }

  late final _spine_physics_constraint_pose_setPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_pose,
                  spine_physics_constraint_pose)>>(
      'spine_physics_constraint_pose_set');
  late final _spine_physics_constraint_pose_set =
      _spine_physics_constraint_pose_setPtr.asFunction<
          void Function(
              spine_physics_constraint_pose, spine_physics_constraint_pose)>();

  double spine_physics_constraint_pose_get_inertia(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_inertia(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_inertiaPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
      'spine_physics_constraint_pose_get_inertia');
  late final _spine_physics_constraint_pose_get_inertia =
      _spine_physics_constraint_pose_get_inertiaPtr
          .asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_inertia(
    spine_physics_constraint_pose self,
    double inertia,
  ) {
    return _spine_physics_constraint_pose_set_inertia(
      self,
      inertia,
    );
  }

  late final _spine_physics_constraint_pose_set_inertiaPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_pose,
              ffi.Float)>>('spine_physics_constraint_pose_set_inertia');
  late final _spine_physics_constraint_pose_set_inertia =
      _spine_physics_constraint_pose_set_inertiaPtr
          .asFunction<void Function(spine_physics_constraint_pose, double)>();

  double spine_physics_constraint_pose_get_strength(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_strength(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_strengthPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
      'spine_physics_constraint_pose_get_strength');
  late final _spine_physics_constraint_pose_get_strength =
      _spine_physics_constraint_pose_get_strengthPtr
          .asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_strength(
    spine_physics_constraint_pose self,
    double strength,
  ) {
    return _spine_physics_constraint_pose_set_strength(
      self,
      strength,
    );
  }

  late final _spine_physics_constraint_pose_set_strengthPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_pose,
              ffi.Float)>>('spine_physics_constraint_pose_set_strength');
  late final _spine_physics_constraint_pose_set_strength =
      _spine_physics_constraint_pose_set_strengthPtr
          .asFunction<void Function(spine_physics_constraint_pose, double)>();

  double spine_physics_constraint_pose_get_damping(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_damping(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_dampingPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
      'spine_physics_constraint_pose_get_damping');
  late final _spine_physics_constraint_pose_get_damping =
      _spine_physics_constraint_pose_get_dampingPtr
          .asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_damping(
    spine_physics_constraint_pose self,
    double damping,
  ) {
    return _spine_physics_constraint_pose_set_damping(
      self,
      damping,
    );
  }

  late final _spine_physics_constraint_pose_set_dampingPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_pose,
              ffi.Float)>>('spine_physics_constraint_pose_set_damping');
  late final _spine_physics_constraint_pose_set_damping =
      _spine_physics_constraint_pose_set_dampingPtr
          .asFunction<void Function(spine_physics_constraint_pose, double)>();

  double spine_physics_constraint_pose_get_mass_inverse(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_mass_inverse(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_mass_inversePtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
      'spine_physics_constraint_pose_get_mass_inverse');
  late final _spine_physics_constraint_pose_get_mass_inverse =
      _spine_physics_constraint_pose_get_mass_inversePtr
          .asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_mass_inverse(
    spine_physics_constraint_pose self,
    double massInverse,
  ) {
    return _spine_physics_constraint_pose_set_mass_inverse(
      self,
      massInverse,
    );
  }

  late final _spine_physics_constraint_pose_set_mass_inversePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_pose,
              ffi.Float)>>('spine_physics_constraint_pose_set_mass_inverse');
  late final _spine_physics_constraint_pose_set_mass_inverse =
      _spine_physics_constraint_pose_set_mass_inversePtr
          .asFunction<void Function(spine_physics_constraint_pose, double)>();

  double spine_physics_constraint_pose_get_wind(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_wind(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_windPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
      'spine_physics_constraint_pose_get_wind');
  late final _spine_physics_constraint_pose_get_wind =
      _spine_physics_constraint_pose_get_windPtr
          .asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_wind(
    spine_physics_constraint_pose self,
    double wind,
  ) {
    return _spine_physics_constraint_pose_set_wind(
      self,
      wind,
    );
  }

  late final _spine_physics_constraint_pose_set_windPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_pose,
              ffi.Float)>>('spine_physics_constraint_pose_set_wind');
  late final _spine_physics_constraint_pose_set_wind =
      _spine_physics_constraint_pose_set_windPtr
          .asFunction<void Function(spine_physics_constraint_pose, double)>();

  double spine_physics_constraint_pose_get_gravity(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_gravity(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_gravityPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
      'spine_physics_constraint_pose_get_gravity');
  late final _spine_physics_constraint_pose_get_gravity =
      _spine_physics_constraint_pose_get_gravityPtr
          .asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_gravity(
    spine_physics_constraint_pose self,
    double gravity,
  ) {
    return _spine_physics_constraint_pose_set_gravity(
      self,
      gravity,
    );
  }

  late final _spine_physics_constraint_pose_set_gravityPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_pose,
              ffi.Float)>>('spine_physics_constraint_pose_set_gravity');
  late final _spine_physics_constraint_pose_set_gravity =
      _spine_physics_constraint_pose_set_gravityPtr
          .asFunction<void Function(spine_physics_constraint_pose, double)>();

  double spine_physics_constraint_pose_get_mix(
    spine_physics_constraint_pose self,
  ) {
    return _spine_physics_constraint_pose_get_mix(
      self,
    );
  }

  late final _spine_physics_constraint_pose_get_mixPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_physics_constraint_pose)>>(
      'spine_physics_constraint_pose_get_mix');
  late final _spine_physics_constraint_pose_get_mix =
      _spine_physics_constraint_pose_get_mixPtr
          .asFunction<double Function(spine_physics_constraint_pose)>();

  void spine_physics_constraint_pose_set_mix(
    spine_physics_constraint_pose self,
    double mix,
  ) {
    return _spine_physics_constraint_pose_set_mix(
      self,
      mix,
    );
  }

  late final _spine_physics_constraint_pose_set_mixPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_pose,
              ffi.Float)>>('spine_physics_constraint_pose_set_mix');
  late final _spine_physics_constraint_pose_set_mix =
      _spine_physics_constraint_pose_set_mixPtr
          .asFunction<void Function(spine_physics_constraint_pose, double)>();

  spine_physics_constraint_reset_timeline
      spine_physics_constraint_reset_timeline_create(
    int frameCount,
    int constraintIndex,
  ) {
    return _spine_physics_constraint_reset_timeline_create(
      frameCount,
      constraintIndex,
    );
  }

  late final _spine_physics_constraint_reset_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_physics_constraint_reset_timeline Function(ffi.Size,
              ffi.Int)>>('spine_physics_constraint_reset_timeline_create');
  late final _spine_physics_constraint_reset_timeline_create =
      _spine_physics_constraint_reset_timeline_createPtr.asFunction<
          spine_physics_constraint_reset_timeline Function(int, int)>();

  void spine_physics_constraint_reset_timeline_dispose(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_reset_timeline)>>(
      'spine_physics_constraint_reset_timeline_dispose');
  late final _spine_physics_constraint_reset_timeline_dispose =
      _spine_physics_constraint_reset_timeline_disposePtr
          .asFunction<void Function(spine_physics_constraint_reset_timeline)>();

  spine_rtti spine_physics_constraint_reset_timeline_get_rtti(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_physics_constraint_reset_timeline)>>(
      'spine_physics_constraint_reset_timeline_get_rtti');
  late final _spine_physics_constraint_reset_timeline_get_rtti =
      _spine_physics_constraint_reset_timeline_get_rttiPtr.asFunction<
          spine_rtti Function(spine_physics_constraint_reset_timeline)>();

  void spine_physics_constraint_reset_timeline_apply(
    spine_physics_constraint_reset_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_reset_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_reset_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_reset_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_reset_timeline_apply');
  late final _spine_physics_constraint_reset_timeline_apply =
      _spine_physics_constraint_reset_timeline_applyPtr.asFunction<
          void Function(spine_physics_constraint_reset_timeline, spine_skeleton,
              double, double, spine_array_event, double, int, int, bool)>();

  int spine_physics_constraint_reset_timeline_get_frame_count(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_frame_countPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_get_frame_count');
  late final _spine_physics_constraint_reset_timeline_get_frame_count =
      _spine_physics_constraint_reset_timeline_get_frame_countPtr
          .asFunction<int Function(spine_physics_constraint_reset_timeline)>();

  int spine_physics_constraint_reset_timeline_get_constraint_index(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_get_constraint_index');
  late final _spine_physics_constraint_reset_timeline_get_constraint_index =
      _spine_physics_constraint_reset_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_reset_timeline)>();

  void spine_physics_constraint_reset_timeline_set_frame(
    spine_physics_constraint_reset_timeline self,
    int frame,
    double time,
  ) {
    return _spine_physics_constraint_reset_timeline_set_frame(
      self,
      frame,
      time,
    );
  }

  late final _spine_physics_constraint_reset_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_reset_timeline, ffi.Int,
              ffi.Float)>>('spine_physics_constraint_reset_timeline_set_frame');
  late final _spine_physics_constraint_reset_timeline_set_frame =
      _spine_physics_constraint_reset_timeline_set_framePtr.asFunction<
          void Function(
              spine_physics_constraint_reset_timeline, int, double)>();

  int spine_physics_constraint_reset_timeline_get_frame_entries(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_frame_entriesPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_get_frame_entries');
  late final _spine_physics_constraint_reset_timeline_get_frame_entries =
      _spine_physics_constraint_reset_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_reset_timeline)>();

  spine_array_float spine_physics_constraint_reset_timeline_get_frames(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_physics_constraint_reset_timeline)>>(
      'spine_physics_constraint_reset_timeline_get_frames');
  late final _spine_physics_constraint_reset_timeline_get_frames =
      _spine_physics_constraint_reset_timeline_get_framesPtr.asFunction<
          spine_array_float Function(
              spine_physics_constraint_reset_timeline)>();

  double spine_physics_constraint_reset_timeline_get_duration(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<
              ffi.Float Function(spine_physics_constraint_reset_timeline)>>(
      'spine_physics_constraint_reset_timeline_get_duration');
  late final _spine_physics_constraint_reset_timeline_get_duration =
      _spine_physics_constraint_reset_timeline_get_durationPtr.asFunction<
          double Function(spine_physics_constraint_reset_timeline)>();

  spine_array_property_id
      spine_physics_constraint_reset_timeline_get_property_ids(
    spine_physics_constraint_reset_timeline self,
  ) {
    return _spine_physics_constraint_reset_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_reset_timeline_get_property_idsPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_array_property_id Function(
                      spine_physics_constraint_reset_timeline)>>(
          'spine_physics_constraint_reset_timeline_get_property_ids');
  late final _spine_physics_constraint_reset_timeline_get_property_ids =
      _spine_physics_constraint_reset_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(
              spine_physics_constraint_reset_timeline)>();

  void spine_physics_constraint_reset_timeline_set_constraint_index(
    spine_physics_constraint_reset_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_reset_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_reset_timeline_set_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_reset_timeline, ffi.Int)>>(
          'spine_physics_constraint_reset_timeline_set_constraint_index');
  late final _spine_physics_constraint_reset_timeline_set_constraint_index =
      _spine_physics_constraint_reset_timeline_set_constraint_indexPtr
          .asFunction<
              void Function(spine_physics_constraint_reset_timeline, int)>();

  spine_rtti spine_physics_constraint_reset_timeline_rtti() {
    return _spine_physics_constraint_reset_timeline_rtti();
  }

  late final _spine_physics_constraint_reset_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_physics_constraint_reset_timeline_rtti');
  late final _spine_physics_constraint_reset_timeline_rtti =
      _spine_physics_constraint_reset_timeline_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_physics_constraint_strength_timeline
      spine_physics_constraint_strength_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_strength_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_strength_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_physics_constraint_strength_timeline Function(
              ffi.Size,
              ffi.Size,
              ffi.Int)>>('spine_physics_constraint_strength_timeline_create');
  late final _spine_physics_constraint_strength_timeline_create =
      _spine_physics_constraint_strength_timeline_createPtr.asFunction<
          spine_physics_constraint_strength_timeline Function(int, int, int)>();

  void spine_physics_constraint_strength_timeline_dispose(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_strength_timeline)>>(
      'spine_physics_constraint_strength_timeline_dispose');
  late final _spine_physics_constraint_strength_timeline_dispose =
      _spine_physics_constraint_strength_timeline_disposePtr.asFunction<
          void Function(spine_physics_constraint_strength_timeline)>();

  spine_rtti spine_physics_constraint_strength_timeline_get_rtti(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_physics_constraint_strength_timeline)>>(
      'spine_physics_constraint_strength_timeline_get_rtti');
  late final _spine_physics_constraint_strength_timeline_get_rtti =
      _spine_physics_constraint_strength_timeline_get_rttiPtr.asFunction<
          spine_rtti Function(spine_physics_constraint_strength_timeline)>();

  void spine_physics_constraint_strength_timeline_apply(
    spine_physics_constraint_strength_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_strength_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_strength_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_strength_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_strength_timeline_apply');
  late final _spine_physics_constraint_strength_timeline_apply =
      _spine_physics_constraint_strength_timeline_applyPtr.asFunction<
          void Function(
              spine_physics_constraint_strength_timeline,
              spine_skeleton,
              double,
              double,
              spine_array_event,
              double,
              int,
              int,
              bool)>();

  void spine_physics_constraint_strength_timeline_set_frame(
    spine_physics_constraint_strength_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_strength_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_strength_timeline_set_framePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_strength_timeline,
                  ffi.Size, ffi.Float, ffi.Float)>>(
      'spine_physics_constraint_strength_timeline_set_frame');
  late final _spine_physics_constraint_strength_timeline_set_frame =
      _spine_physics_constraint_strength_timeline_set_framePtr.asFunction<
          void Function(spine_physics_constraint_strength_timeline, int, double,
              double)>();

  double spine_physics_constraint_strength_timeline_get_curve_value(
    spine_physics_constraint_strength_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_strength_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_curve_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_strength_timeline, ffi.Float)>>(
          'spine_physics_constraint_strength_timeline_get_curve_value');
  late final _spine_physics_constraint_strength_timeline_get_curve_value =
      _spine_physics_constraint_strength_timeline_get_curve_valuePtr.asFunction<
          double Function(
              spine_physics_constraint_strength_timeline, double)>();

  double spine_physics_constraint_strength_timeline_get_relative_value(
    spine_physics_constraint_strength_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_strength_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_relative_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_strength_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_strength_timeline_get_relative_value');
  late final _spine_physics_constraint_strength_timeline_get_relative_value =
      _spine_physics_constraint_strength_timeline_get_relative_valuePtr
          .asFunction<
              double Function(spine_physics_constraint_strength_timeline,
                  double, double, int, double, double)>();

  double spine_physics_constraint_strength_timeline_get_absolute_value_1(
    spine_physics_constraint_strength_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_strength_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_absolute_value_1Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_strength_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_strength_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_strength_timeline_get_absolute_value_1 =
      _spine_physics_constraint_strength_timeline_get_absolute_value_1Ptr
          .asFunction<
              double Function(spine_physics_constraint_strength_timeline,
                  double, double, int, double, double)>();

  double spine_physics_constraint_strength_timeline_get_absolute_value_2(
    spine_physics_constraint_strength_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_strength_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_absolute_value_2Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_strength_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_strength_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_strength_timeline_get_absolute_value_2 =
      _spine_physics_constraint_strength_timeline_get_absolute_value_2Ptr
          .asFunction<
              double Function(spine_physics_constraint_strength_timeline,
                  double, double, int, double, double, double)>();

  double spine_physics_constraint_strength_timeline_get_scale_value(
    spine_physics_constraint_strength_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_strength_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_scale_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_strength_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_strength_timeline_get_scale_value');
  late final _spine_physics_constraint_strength_timeline_get_scale_value =
      _spine_physics_constraint_strength_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_strength_timeline, double,
              double, int, int, double, double)>();

  void spine_physics_constraint_strength_timeline_set_linear(
    spine_physics_constraint_strength_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_strength_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_strength_timeline_set_linearPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_strength_timeline, ffi.Size)>>(
          'spine_physics_constraint_strength_timeline_set_linear');
  late final _spine_physics_constraint_strength_timeline_set_linear =
      _spine_physics_constraint_strength_timeline_set_linearPtr.asFunction<
          void Function(spine_physics_constraint_strength_timeline, int)>();

  void spine_physics_constraint_strength_timeline_set_stepped(
    spine_physics_constraint_strength_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_strength_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_strength_timeline_set_steppedPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_strength_timeline, ffi.Size)>>(
          'spine_physics_constraint_strength_timeline_set_stepped');
  late final _spine_physics_constraint_strength_timeline_set_stepped =
      _spine_physics_constraint_strength_timeline_set_steppedPtr.asFunction<
          void Function(spine_physics_constraint_strength_timeline, int)>();

  void spine_physics_constraint_strength_timeline_set_bezier(
    spine_physics_constraint_strength_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_strength_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_strength_timeline_set_bezierPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_strength_timeline,
                      ffi.Size,
                      ffi.Size,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_strength_timeline_set_bezier');
  late final _spine_physics_constraint_strength_timeline_set_bezier =
      _spine_physics_constraint_strength_timeline_set_bezierPtr.asFunction<
          void Function(
              spine_physics_constraint_strength_timeline,
              int,
              int,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double)>();

  double spine_physics_constraint_strength_timeline_get_bezier_value(
    spine_physics_constraint_strength_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_strength_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_bezier_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_strength_timeline,
                      ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_physics_constraint_strength_timeline_get_bezier_value');
  late final _spine_physics_constraint_strength_timeline_get_bezier_value =
      _spine_physics_constraint_strength_timeline_get_bezier_valuePtr
          .asFunction<
              double Function(spine_physics_constraint_strength_timeline,
                  double, int, int, int)>();

  spine_array_float spine_physics_constraint_strength_timeline_get_curves(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_curvesPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_array_float Function(
                      spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_curves');
  late final _spine_physics_constraint_strength_timeline_get_curves =
      _spine_physics_constraint_strength_timeline_get_curvesPtr.asFunction<
          spine_array_float Function(
              spine_physics_constraint_strength_timeline)>();

  int spine_physics_constraint_strength_timeline_get_frame_entries(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_frame_entriesPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(
                      spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_frame_entries');
  late final _spine_physics_constraint_strength_timeline_get_frame_entries =
      _spine_physics_constraint_strength_timeline_get_frame_entriesPtr
          .asFunction<
              int Function(spine_physics_constraint_strength_timeline)>();

  int spine_physics_constraint_strength_timeline_get_frame_count(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_frame_countPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(
                      spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_frame_count');
  late final _spine_physics_constraint_strength_timeline_get_frame_count =
      _spine_physics_constraint_strength_timeline_get_frame_countPtr.asFunction<
          int Function(spine_physics_constraint_strength_timeline)>();

  spine_array_float spine_physics_constraint_strength_timeline_get_frames(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_framesPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_array_float Function(
                      spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_frames');
  late final _spine_physics_constraint_strength_timeline_get_frames =
      _spine_physics_constraint_strength_timeline_get_framesPtr.asFunction<
          spine_array_float Function(
              spine_physics_constraint_strength_timeline)>();

  double spine_physics_constraint_strength_timeline_get_duration(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_durationPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_duration');
  late final _spine_physics_constraint_strength_timeline_get_duration =
      _spine_physics_constraint_strength_timeline_get_durationPtr.asFunction<
          double Function(spine_physics_constraint_strength_timeline)>();

  spine_array_property_id
      spine_physics_constraint_strength_timeline_get_property_ids(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_property_idsPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_array_property_id Function(
                      spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_property_ids');
  late final _spine_physics_constraint_strength_timeline_get_property_ids =
      _spine_physics_constraint_strength_timeline_get_property_idsPtr
          .asFunction<
              spine_array_property_id Function(
                  spine_physics_constraint_strength_timeline)>();

  int spine_physics_constraint_strength_timeline_get_constraint_index(
    spine_physics_constraint_strength_timeline self,
  ) {
    return _spine_physics_constraint_strength_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_strength_timeline_get_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(
                      spine_physics_constraint_strength_timeline)>>(
          'spine_physics_constraint_strength_timeline_get_constraint_index');
  late final _spine_physics_constraint_strength_timeline_get_constraint_index =
      _spine_physics_constraint_strength_timeline_get_constraint_indexPtr
          .asFunction<
              int Function(spine_physics_constraint_strength_timeline)>();

  void spine_physics_constraint_strength_timeline_set_constraint_index(
    spine_physics_constraint_strength_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_strength_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_strength_timeline_set_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_strength_timeline, ffi.Int)>>(
          'spine_physics_constraint_strength_timeline_set_constraint_index');
  late final _spine_physics_constraint_strength_timeline_set_constraint_index =
      _spine_physics_constraint_strength_timeline_set_constraint_indexPtr
          .asFunction<
              void Function(spine_physics_constraint_strength_timeline, int)>();

  spine_rtti spine_physics_constraint_strength_timeline_rtti() {
    return _spine_physics_constraint_strength_timeline_rtti();
  }

  late final _spine_physics_constraint_strength_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_physics_constraint_strength_timeline_rtti');
  late final _spine_physics_constraint_strength_timeline_rtti =
      _spine_physics_constraint_strength_timeline_rttiPtr
          .asFunction<spine_rtti Function()>();

  void spine_physics_constraint_timeline_dispose(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_timeline)>>(
      'spine_physics_constraint_timeline_dispose');
  late final _spine_physics_constraint_timeline_dispose =
      _spine_physics_constraint_timeline_disposePtr
          .asFunction<void Function(spine_physics_constraint_timeline)>();

  spine_rtti spine_physics_constraint_timeline_get_rtti(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_physics_constraint_timeline)>>(
      'spine_physics_constraint_timeline_get_rtti');
  late final _spine_physics_constraint_timeline_get_rtti =
      _spine_physics_constraint_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_physics_constraint_timeline)>();

  void spine_physics_constraint_timeline_apply(
    spine_physics_constraint_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_timeline_apply');
  late final _spine_physics_constraint_timeline_apply =
      _spine_physics_constraint_timeline_applyPtr.asFunction<
          void Function(spine_physics_constraint_timeline, spine_skeleton,
              double, double, spine_array_event, double, int, int, bool)>();

  void spine_physics_constraint_timeline_set_frame(
    spine_physics_constraint_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_timeline,
              ffi.Size,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_timeline_set_frame');
  late final _spine_physics_constraint_timeline_set_frame =
      _spine_physics_constraint_timeline_set_framePtr.asFunction<
          void Function(
              spine_physics_constraint_timeline, int, double, double)>();

  double spine_physics_constraint_timeline_get_curve_value(
    spine_physics_constraint_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_timeline_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_physics_constraint_timeline,
              ffi.Float)>>('spine_physics_constraint_timeline_get_curve_value');
  late final _spine_physics_constraint_timeline_get_curve_value =
      _spine_physics_constraint_timeline_get_curve_valuePtr.asFunction<
          double Function(spine_physics_constraint_timeline, double)>();

  double spine_physics_constraint_timeline_get_relative_value(
    spine_physics_constraint_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_timeline_get_relative_valuePtr = _lookup<
          ffi.NativeFunction<
              ffi.Float Function(spine_physics_constraint_timeline, ffi.Float,
                  ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
      'spine_physics_constraint_timeline_get_relative_value');
  late final _spine_physics_constraint_timeline_get_relative_value =
      _spine_physics_constraint_timeline_get_relative_valuePtr.asFunction<
          double Function(spine_physics_constraint_timeline, double, double,
              int, double, double)>();

  double spine_physics_constraint_timeline_get_absolute_value_1(
    spine_physics_constraint_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_timeline_get_absolute_value_1Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_timeline_get_absolute_value_1 =
      _spine_physics_constraint_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(spine_physics_constraint_timeline, double, double,
              int, double, double)>();

  double spine_physics_constraint_timeline_get_absolute_value_2(
    spine_physics_constraint_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_timeline_get_absolute_value_2Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_timeline_get_absolute_value_2 =
      _spine_physics_constraint_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_physics_constraint_timeline, double, double,
              int, double, double, double)>();

  double spine_physics_constraint_timeline_get_scale_value(
    spine_physics_constraint_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_physics_constraint_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_timeline_get_scale_value');
  late final _spine_physics_constraint_timeline_get_scale_value =
      _spine_physics_constraint_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_timeline, double, double,
              int, int, double, double)>();

  void spine_physics_constraint_timeline_set_linear(
    spine_physics_constraint_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_timeline,
              ffi.Size)>>('spine_physics_constraint_timeline_set_linear');
  late final _spine_physics_constraint_timeline_set_linear =
      _spine_physics_constraint_timeline_set_linearPtr
          .asFunction<void Function(spine_physics_constraint_timeline, int)>();

  void spine_physics_constraint_timeline_set_stepped(
    spine_physics_constraint_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_timeline_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_timeline,
              ffi.Size)>>('spine_physics_constraint_timeline_set_stepped');
  late final _spine_physics_constraint_timeline_set_stepped =
      _spine_physics_constraint_timeline_set_steppedPtr
          .asFunction<void Function(spine_physics_constraint_timeline, int)>();

  void spine_physics_constraint_timeline_set_bezier(
    spine_physics_constraint_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_timeline_set_bezier');
  late final _spine_physics_constraint_timeline_set_bezier =
      _spine_physics_constraint_timeline_set_bezierPtr.asFunction<
          void Function(
              spine_physics_constraint_timeline,
              int,
              int,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double)>();

  double spine_physics_constraint_timeline_get_bezier_value(
    spine_physics_constraint_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_physics_constraint_timeline,
              ffi.Float,
              ffi.Size,
              ffi.Size,
              ffi.Size)>>('spine_physics_constraint_timeline_get_bezier_value');
  late final _spine_physics_constraint_timeline_get_bezier_value =
      _spine_physics_constraint_timeline_get_bezier_valuePtr.asFunction<
          double Function(
              spine_physics_constraint_timeline, double, int, int, int)>();

  spine_array_float spine_physics_constraint_timeline_get_curves(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_physics_constraint_timeline)>>(
      'spine_physics_constraint_timeline_get_curves');
  late final _spine_physics_constraint_timeline_get_curves =
      _spine_physics_constraint_timeline_get_curvesPtr.asFunction<
          spine_array_float Function(spine_physics_constraint_timeline)>();

  int spine_physics_constraint_timeline_get_frame_entries(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_frame_entriesPtr = _lookup<
          ffi.NativeFunction<
              ffi.Size Function(spine_physics_constraint_timeline)>>(
      'spine_physics_constraint_timeline_get_frame_entries');
  late final _spine_physics_constraint_timeline_get_frame_entries =
      _spine_physics_constraint_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_timeline)>();

  int spine_physics_constraint_timeline_get_frame_count(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_frame_countPtr = _lookup<
          ffi.NativeFunction<
              ffi.Size Function(spine_physics_constraint_timeline)>>(
      'spine_physics_constraint_timeline_get_frame_count');
  late final _spine_physics_constraint_timeline_get_frame_count =
      _spine_physics_constraint_timeline_get_frame_countPtr
          .asFunction<int Function(spine_physics_constraint_timeline)>();

  spine_array_float spine_physics_constraint_timeline_get_frames(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_physics_constraint_timeline)>>(
      'spine_physics_constraint_timeline_get_frames');
  late final _spine_physics_constraint_timeline_get_frames =
      _spine_physics_constraint_timeline_get_framesPtr.asFunction<
          spine_array_float Function(spine_physics_constraint_timeline)>();

  double spine_physics_constraint_timeline_get_duration(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<
              ffi.Float Function(spine_physics_constraint_timeline)>>(
      'spine_physics_constraint_timeline_get_duration');
  late final _spine_physics_constraint_timeline_get_duration =
      _spine_physics_constraint_timeline_get_durationPtr
          .asFunction<double Function(spine_physics_constraint_timeline)>();

  spine_array_property_id spine_physics_constraint_timeline_get_property_ids(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(
                  spine_physics_constraint_timeline)>>(
      'spine_physics_constraint_timeline_get_property_ids');
  late final _spine_physics_constraint_timeline_get_property_ids =
      _spine_physics_constraint_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(
              spine_physics_constraint_timeline)>();

  int spine_physics_constraint_timeline_get_constraint_index(
    spine_physics_constraint_timeline self,
  ) {
    return _spine_physics_constraint_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_timeline_get_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(spine_physics_constraint_timeline)>>(
          'spine_physics_constraint_timeline_get_constraint_index');
  late final _spine_physics_constraint_timeline_get_constraint_index =
      _spine_physics_constraint_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_timeline)>();

  void spine_physics_constraint_timeline_set_constraint_index(
    spine_physics_constraint_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_timeline_set_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_timeline, ffi.Int)>>(
          'spine_physics_constraint_timeline_set_constraint_index');
  late final _spine_physics_constraint_timeline_set_constraint_index =
      _spine_physics_constraint_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_physics_constraint_timeline, int)>();

  spine_rtti spine_physics_constraint_timeline_rtti() {
    return _spine_physics_constraint_timeline_rtti();
  }

  late final _spine_physics_constraint_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_physics_constraint_timeline_rtti');
  late final _spine_physics_constraint_timeline_rtti =
      _spine_physics_constraint_timeline_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_physics_constraint_wind_timeline
      spine_physics_constraint_wind_timeline_create(
    int frameCount,
    int bezierCount,
    int physicsConstraintIndex,
  ) {
    return _spine_physics_constraint_wind_timeline_create(
      frameCount,
      bezierCount,
      physicsConstraintIndex,
    );
  }

  late final _spine_physics_constraint_wind_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_physics_constraint_wind_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_physics_constraint_wind_timeline_create');
  late final _spine_physics_constraint_wind_timeline_create =
      _spine_physics_constraint_wind_timeline_createPtr.asFunction<
          spine_physics_constraint_wind_timeline Function(int, int, int)>();

  void spine_physics_constraint_wind_timeline_dispose(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_dispose(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_physics_constraint_wind_timeline)>>(
      'spine_physics_constraint_wind_timeline_dispose');
  late final _spine_physics_constraint_wind_timeline_dispose =
      _spine_physics_constraint_wind_timeline_disposePtr
          .asFunction<void Function(spine_physics_constraint_wind_timeline)>();

  spine_rtti spine_physics_constraint_wind_timeline_get_rtti(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_rtti(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_physics_constraint_wind_timeline)>>(
      'spine_physics_constraint_wind_timeline_get_rtti');
  late final _spine_physics_constraint_wind_timeline_get_rtti =
      _spine_physics_constraint_wind_timeline_get_rttiPtr.asFunction<
          spine_rtti Function(spine_physics_constraint_wind_timeline)>();

  void spine_physics_constraint_wind_timeline_apply(
    spine_physics_constraint_wind_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_physics_constraint_wind_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_physics_constraint_wind_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_wind_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_physics_constraint_wind_timeline_apply');
  late final _spine_physics_constraint_wind_timeline_apply =
      _spine_physics_constraint_wind_timeline_applyPtr.asFunction<
          void Function(spine_physics_constraint_wind_timeline, spine_skeleton,
              double, double, spine_array_event, double, int, int, bool)>();

  void spine_physics_constraint_wind_timeline_set_frame(
    spine_physics_constraint_wind_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_physics_constraint_wind_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_physics_constraint_wind_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_wind_timeline,
              ffi.Size,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_wind_timeline_set_frame');
  late final _spine_physics_constraint_wind_timeline_set_frame =
      _spine_physics_constraint_wind_timeline_set_framePtr.asFunction<
          void Function(
              spine_physics_constraint_wind_timeline, int, double, double)>();

  double spine_physics_constraint_wind_timeline_get_curve_value(
    spine_physics_constraint_wind_timeline self,
    double time,
  ) {
    return _spine_physics_constraint_wind_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_curve_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_wind_timeline, ffi.Float)>>(
          'spine_physics_constraint_wind_timeline_get_curve_value');
  late final _spine_physics_constraint_wind_timeline_get_curve_value =
      _spine_physics_constraint_wind_timeline_get_curve_valuePtr.asFunction<
          double Function(spine_physics_constraint_wind_timeline, double)>();

  double spine_physics_constraint_wind_timeline_get_relative_value(
    spine_physics_constraint_wind_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_wind_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_relative_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_wind_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_wind_timeline_get_relative_value');
  late final _spine_physics_constraint_wind_timeline_get_relative_value =
      _spine_physics_constraint_wind_timeline_get_relative_valuePtr.asFunction<
          double Function(spine_physics_constraint_wind_timeline, double,
              double, int, double, double)>();

  double spine_physics_constraint_wind_timeline_get_absolute_value_1(
    spine_physics_constraint_wind_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_wind_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_absolute_value_1Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_wind_timeline,
                      ffi.Float, ffi.Float, ffi.Int32, ffi.Float, ffi.Float)>>(
          'spine_physics_constraint_wind_timeline_get_absolute_value_1');
  late final _spine_physics_constraint_wind_timeline_get_absolute_value_1 =
      _spine_physics_constraint_wind_timeline_get_absolute_value_1Ptr
          .asFunction<
              double Function(spine_physics_constraint_wind_timeline, double,
                  double, int, double, double)>();

  double spine_physics_constraint_wind_timeline_get_absolute_value_2(
    spine_physics_constraint_wind_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_physics_constraint_wind_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_absolute_value_2Ptr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_wind_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_wind_timeline_get_absolute_value_2');
  late final _spine_physics_constraint_wind_timeline_get_absolute_value_2 =
      _spine_physics_constraint_wind_timeline_get_absolute_value_2Ptr
          .asFunction<
              double Function(spine_physics_constraint_wind_timeline, double,
                  double, int, double, double, double)>();

  double spine_physics_constraint_wind_timeline_get_scale_value(
    spine_physics_constraint_wind_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_physics_constraint_wind_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_scale_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(
                      spine_physics_constraint_wind_timeline,
                      ffi.Float,
                      ffi.Float,
                      ffi.Int32,
                      ffi.Int32,
                      ffi.Float,
                      ffi.Float)>>(
          'spine_physics_constraint_wind_timeline_get_scale_value');
  late final _spine_physics_constraint_wind_timeline_get_scale_value =
      _spine_physics_constraint_wind_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_physics_constraint_wind_timeline, double,
              double, int, int, double, double)>();

  void spine_physics_constraint_wind_timeline_set_linear(
    spine_physics_constraint_wind_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_wind_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_wind_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_wind_timeline,
              ffi.Size)>>('spine_physics_constraint_wind_timeline_set_linear');
  late final _spine_physics_constraint_wind_timeline_set_linear =
      _spine_physics_constraint_wind_timeline_set_linearPtr.asFunction<
          void Function(spine_physics_constraint_wind_timeline, int)>();

  void spine_physics_constraint_wind_timeline_set_stepped(
    spine_physics_constraint_wind_timeline self,
    int frame,
  ) {
    return _spine_physics_constraint_wind_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_physics_constraint_wind_timeline_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_physics_constraint_wind_timeline,
              ffi.Size)>>('spine_physics_constraint_wind_timeline_set_stepped');
  late final _spine_physics_constraint_wind_timeline_set_stepped =
      _spine_physics_constraint_wind_timeline_set_steppedPtr.asFunction<
          void Function(spine_physics_constraint_wind_timeline, int)>();

  void spine_physics_constraint_wind_timeline_set_bezier(
    spine_physics_constraint_wind_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_physics_constraint_wind_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_physics_constraint_wind_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_physics_constraint_wind_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_physics_constraint_wind_timeline_set_bezier');
  late final _spine_physics_constraint_wind_timeline_set_bezier =
      _spine_physics_constraint_wind_timeline_set_bezierPtr.asFunction<
          void Function(
              spine_physics_constraint_wind_timeline,
              int,
              int,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double)>();

  double spine_physics_constraint_wind_timeline_get_bezier_value(
    spine_physics_constraint_wind_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_physics_constraint_wind_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_bezier_valuePtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Float Function(spine_physics_constraint_wind_timeline,
                      ffi.Float, ffi.Size, ffi.Size, ffi.Size)>>(
          'spine_physics_constraint_wind_timeline_get_bezier_value');
  late final _spine_physics_constraint_wind_timeline_get_bezier_value =
      _spine_physics_constraint_wind_timeline_get_bezier_valuePtr.asFunction<
          double Function(
              spine_physics_constraint_wind_timeline, double, int, int, int)>();

  spine_array_float spine_physics_constraint_wind_timeline_get_curves(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_curves(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_physics_constraint_wind_timeline)>>(
      'spine_physics_constraint_wind_timeline_get_curves');
  late final _spine_physics_constraint_wind_timeline_get_curves =
      _spine_physics_constraint_wind_timeline_get_curvesPtr.asFunction<
          spine_array_float Function(spine_physics_constraint_wind_timeline)>();

  int spine_physics_constraint_wind_timeline_get_frame_entries(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_frame_entriesPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_get_frame_entries');
  late final _spine_physics_constraint_wind_timeline_get_frame_entries =
      _spine_physics_constraint_wind_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_physics_constraint_wind_timeline)>();

  int spine_physics_constraint_wind_timeline_get_frame_count(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_frame_countPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_get_frame_count');
  late final _spine_physics_constraint_wind_timeline_get_frame_count =
      _spine_physics_constraint_wind_timeline_get_frame_countPtr
          .asFunction<int Function(spine_physics_constraint_wind_timeline)>();

  spine_array_float spine_physics_constraint_wind_timeline_get_frames(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_frames(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(
                  spine_physics_constraint_wind_timeline)>>(
      'spine_physics_constraint_wind_timeline_get_frames');
  late final _spine_physics_constraint_wind_timeline_get_frames =
      _spine_physics_constraint_wind_timeline_get_framesPtr.asFunction<
          spine_array_float Function(spine_physics_constraint_wind_timeline)>();

  double spine_physics_constraint_wind_timeline_get_duration(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_duration(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<
              ffi.Float Function(spine_physics_constraint_wind_timeline)>>(
      'spine_physics_constraint_wind_timeline_get_duration');
  late final _spine_physics_constraint_wind_timeline_get_duration =
      _spine_physics_constraint_wind_timeline_get_durationPtr.asFunction<
          double Function(spine_physics_constraint_wind_timeline)>();

  spine_array_property_id
      spine_physics_constraint_wind_timeline_get_property_ids(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_property_idsPtr =
      _lookup<
              ffi.NativeFunction<
                  spine_array_property_id Function(
                      spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_get_property_ids');
  late final _spine_physics_constraint_wind_timeline_get_property_ids =
      _spine_physics_constraint_wind_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(
              spine_physics_constraint_wind_timeline)>();

  int spine_physics_constraint_wind_timeline_get_constraint_index(
    spine_physics_constraint_wind_timeline self,
  ) {
    return _spine_physics_constraint_wind_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_physics_constraint_wind_timeline_get_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(spine_physics_constraint_wind_timeline)>>(
          'spine_physics_constraint_wind_timeline_get_constraint_index');
  late final _spine_physics_constraint_wind_timeline_get_constraint_index =
      _spine_physics_constraint_wind_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_physics_constraint_wind_timeline)>();

  void spine_physics_constraint_wind_timeline_set_constraint_index(
    spine_physics_constraint_wind_timeline self,
    int inValue,
  ) {
    return _spine_physics_constraint_wind_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_physics_constraint_wind_timeline_set_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_physics_constraint_wind_timeline, ffi.Int)>>(
          'spine_physics_constraint_wind_timeline_set_constraint_index');
  late final _spine_physics_constraint_wind_timeline_set_constraint_index =
      _spine_physics_constraint_wind_timeline_set_constraint_indexPtr
          .asFunction<
              void Function(spine_physics_constraint_wind_timeline, int)>();

  spine_rtti spine_physics_constraint_wind_timeline_rtti() {
    return _spine_physics_constraint_wind_timeline_rtti();
  }

  late final _spine_physics_constraint_wind_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_physics_constraint_wind_timeline_rtti');
  late final _spine_physics_constraint_wind_timeline_rtti =
      _spine_physics_constraint_wind_timeline_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_point_attachment spine_point_attachment_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_point_attachment_create(
      name,
    );
  }

  late final _spine_point_attachment_createPtr = _lookup<
      ffi.NativeFunction<
          spine_point_attachment Function(
              ffi.Pointer<ffi.Char>)>>('spine_point_attachment_create');
  late final _spine_point_attachment_create = _spine_point_attachment_createPtr
      .asFunction<spine_point_attachment Function(ffi.Pointer<ffi.Char>)>();

  void spine_point_attachment_dispose(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_dispose(
      self,
    );
  }

  late final _spine_point_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_point_attachment)>>(
          'spine_point_attachment_dispose');
  late final _spine_point_attachment_dispose =
      _spine_point_attachment_disposePtr
          .asFunction<void Function(spine_point_attachment)>();

  spine_rtti spine_point_attachment_get_rtti(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_rtti(
      self,
    );
  }

  late final _spine_point_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_point_attachment)>>(
          'spine_point_attachment_get_rtti');
  late final _spine_point_attachment_get_rtti =
      _spine_point_attachment_get_rttiPtr
          .asFunction<spine_rtti Function(spine_point_attachment)>();

  double spine_point_attachment_get_x(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_x(
      self,
    );
  }

  late final _spine_point_attachment_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_point_attachment)>>(
          'spine_point_attachment_get_x');
  late final _spine_point_attachment_get_x = _spine_point_attachment_get_xPtr
      .asFunction<double Function(spine_point_attachment)>();

  void spine_point_attachment_set_x(
    spine_point_attachment self,
    double inValue,
  ) {
    return _spine_point_attachment_set_x(
      self,
      inValue,
    );
  }

  late final _spine_point_attachment_set_xPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_point_attachment,
              ffi.Float)>>('spine_point_attachment_set_x');
  late final _spine_point_attachment_set_x = _spine_point_attachment_set_xPtr
      .asFunction<void Function(spine_point_attachment, double)>();

  double spine_point_attachment_get_y(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_y(
      self,
    );
  }

  late final _spine_point_attachment_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_point_attachment)>>(
          'spine_point_attachment_get_y');
  late final _spine_point_attachment_get_y = _spine_point_attachment_get_yPtr
      .asFunction<double Function(spine_point_attachment)>();

  void spine_point_attachment_set_y(
    spine_point_attachment self,
    double inValue,
  ) {
    return _spine_point_attachment_set_y(
      self,
      inValue,
    );
  }

  late final _spine_point_attachment_set_yPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_point_attachment,
              ffi.Float)>>('spine_point_attachment_set_y');
  late final _spine_point_attachment_set_y = _spine_point_attachment_set_yPtr
      .asFunction<void Function(spine_point_attachment, double)>();

  double spine_point_attachment_get_rotation(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_rotation(
      self,
    );
  }

  late final _spine_point_attachment_get_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_point_attachment)>>(
          'spine_point_attachment_get_rotation');
  late final _spine_point_attachment_get_rotation =
      _spine_point_attachment_get_rotationPtr
          .asFunction<double Function(spine_point_attachment)>();

  void spine_point_attachment_set_rotation(
    spine_point_attachment self,
    double inValue,
  ) {
    return _spine_point_attachment_set_rotation(
      self,
      inValue,
    );
  }

  late final _spine_point_attachment_set_rotationPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_point_attachment,
              ffi.Float)>>('spine_point_attachment_set_rotation');
  late final _spine_point_attachment_set_rotation =
      _spine_point_attachment_set_rotationPtr
          .asFunction<void Function(spine_point_attachment, double)>();

  spine_color spine_point_attachment_get_color(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_color(
      self,
    );
  }

  late final _spine_point_attachment_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_point_attachment)>>(
          'spine_point_attachment_get_color');
  late final _spine_point_attachment_get_color =
      _spine_point_attachment_get_colorPtr
          .asFunction<spine_color Function(spine_point_attachment)>();

  void spine_point_attachment_compute_world_position(
    spine_point_attachment self,
    spine_bone_pose bone,
    ffi.Pointer<ffi.Float> ox,
    ffi.Pointer<ffi.Float> oy,
  ) {
    return _spine_point_attachment_compute_world_position(
      self,
      bone,
      ox,
      oy,
    );
  }

  late final _spine_point_attachment_compute_world_positionPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_point_attachment, spine_bone_pose,
                  ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>)>>(
      'spine_point_attachment_compute_world_position');
  late final _spine_point_attachment_compute_world_position =
      _spine_point_attachment_compute_world_positionPtr.asFunction<
          void Function(spine_point_attachment, spine_bone_pose,
              ffi.Pointer<ffi.Float>, ffi.Pointer<ffi.Float>)>();

  double spine_point_attachment_compute_world_rotation(
    spine_point_attachment self,
    spine_bone_pose bone,
  ) {
    return _spine_point_attachment_compute_world_rotation(
      self,
      bone,
    );
  }

  late final _spine_point_attachment_compute_world_rotationPtr = _lookup<
          ffi.NativeFunction<
              ffi.Float Function(spine_point_attachment, spine_bone_pose)>>(
      'spine_point_attachment_compute_world_rotation');
  late final _spine_point_attachment_compute_world_rotation =
      _spine_point_attachment_compute_world_rotationPtr.asFunction<
          double Function(spine_point_attachment, spine_bone_pose)>();

  spine_attachment spine_point_attachment_copy(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_copy(
      self,
    );
  }

  late final _spine_point_attachment_copyPtr = _lookup<
          ffi
          .NativeFunction<spine_attachment Function(spine_point_attachment)>>(
      'spine_point_attachment_copy');
  late final _spine_point_attachment_copy = _spine_point_attachment_copyPtr
      .asFunction<spine_attachment Function(spine_point_attachment)>();

  ffi.Pointer<ffi.Char> spine_point_attachment_get_name(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_name(
      self,
    );
  }

  late final _spine_point_attachment_get_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              spine_point_attachment)>>('spine_point_attachment_get_name');
  late final _spine_point_attachment_get_name =
      _spine_point_attachment_get_namePtr
          .asFunction<ffi.Pointer<ffi.Char> Function(spine_point_attachment)>();

  int spine_point_attachment_get_ref_count(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_point_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_point_attachment)>>(
          'spine_point_attachment_get_ref_count');
  late final _spine_point_attachment_get_ref_count =
      _spine_point_attachment_get_ref_countPtr
          .asFunction<int Function(spine_point_attachment)>();

  void spine_point_attachment_reference(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_reference(
      self,
    );
  }

  late final _spine_point_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_point_attachment)>>(
          'spine_point_attachment_reference');
  late final _spine_point_attachment_reference =
      _spine_point_attachment_referencePtr
          .asFunction<void Function(spine_point_attachment)>();

  void spine_point_attachment_dereference(
    spine_point_attachment self,
  ) {
    return _spine_point_attachment_dereference(
      self,
    );
  }

  late final _spine_point_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_point_attachment)>>(
          'spine_point_attachment_dereference');
  late final _spine_point_attachment_dereference =
      _spine_point_attachment_dereferencePtr
          .asFunction<void Function(spine_point_attachment)>();

  spine_rtti spine_point_attachment_rtti() {
    return _spine_point_attachment_rtti();
  }

  late final _spine_point_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_point_attachment_rtti');
  late final _spine_point_attachment_rtti =
      _spine_point_attachment_rttiPtr.asFunction<spine_rtti Function()>();

  spine_polygon spine_polygon_create() {
    return _spine_polygon_create();
  }

  late final _spine_polygon_createPtr =
      _lookup<ffi.NativeFunction<spine_polygon Function()>>(
          'spine_polygon_create');
  late final _spine_polygon_create =
      _spine_polygon_createPtr.asFunction<spine_polygon Function()>();

  void spine_polygon_dispose(
    spine_polygon self,
  ) {
    return _spine_polygon_dispose(
      self,
    );
  }

  late final _spine_polygon_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_polygon)>>(
          'spine_polygon_dispose');
  late final _spine_polygon_dispose =
      _spine_polygon_disposePtr.asFunction<void Function(spine_polygon)>();

  spine_array_float spine_polygon_get__vertices(
    spine_polygon self,
  ) {
    return _spine_polygon_get__vertices(
      self,
    );
  }

  late final _spine_polygon_get__verticesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_polygon)>>(
          'spine_polygon_get__vertices');
  late final _spine_polygon_get__vertices = _spine_polygon_get__verticesPtr
      .asFunction<spine_array_float Function(spine_polygon)>();

  void spine_polygon_set__vertices(
    spine_polygon self,
    spine_array_float value,
  ) {
    return _spine_polygon_set__vertices(
      self,
      value,
    );
  }

  late final _spine_polygon_set__verticesPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_polygon, spine_array_float)>>(
      'spine_polygon_set__vertices');
  late final _spine_polygon_set__vertices = _spine_polygon_set__verticesPtr
      .asFunction<void Function(spine_polygon, spine_array_float)>();

  int spine_polygon_get__count(
    spine_polygon self,
  ) {
    return _spine_polygon_get__count(
      self,
    );
  }

  late final _spine_polygon_get__countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_polygon)>>(
          'spine_polygon_get__count');
  late final _spine_polygon_get__count =
      _spine_polygon_get__countPtr.asFunction<int Function(spine_polygon)>();

  void spine_polygon_set__count(
    spine_polygon self,
    int value,
  ) {
    return _spine_polygon_set__count(
      self,
      value,
    );
  }

  late final _spine_polygon_set__countPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_polygon, ffi.Int)>>(
          'spine_polygon_set__count');
  late final _spine_polygon_set__count = _spine_polygon_set__countPtr
      .asFunction<void Function(spine_polygon, int)>();

  void spine_posed_dispose(
    spine_posed self,
  ) {
    return _spine_posed_dispose(
      self,
    );
  }

  late final _spine_posed_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_posed)>>(
          'spine_posed_dispose');
  late final _spine_posed_dispose =
      _spine_posed_disposePtr.asFunction<void Function(spine_posed)>();

  void spine_posed_constrained(
    spine_posed self,
  ) {
    return _spine_posed_constrained(
      self,
    );
  }

  late final _spine_posed_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_posed)>>(
          'spine_posed_constrained');
  late final _spine_posed_constrained =
      _spine_posed_constrainedPtr.asFunction<void Function(spine_posed)>();

  void spine_posed_reset_constrained(
    spine_posed self,
  ) {
    return _spine_posed_reset_constrained(
      self,
    );
  }

  late final _spine_posed_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_posed)>>(
          'spine_posed_reset_constrained');
  late final _spine_posed_reset_constrained = _spine_posed_reset_constrainedPtr
      .asFunction<void Function(spine_posed)>();

  bool spine_posed_is_pose_equal_to_applied(
    spine_posed self,
  ) {
    return _spine_posed_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_posed_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_posed)>>(
          'spine_posed_is_pose_equal_to_applied');
  late final _spine_posed_is_pose_equal_to_applied =
      _spine_posed_is_pose_equal_to_appliedPtr
          .asFunction<bool Function(spine_posed)>();

  void spine_posed_active_dispose(
    spine_posed_active self,
  ) {
    return _spine_posed_active_dispose(
      self,
    );
  }

  late final _spine_posed_active_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_posed_active)>>(
          'spine_posed_active_dispose');
  late final _spine_posed_active_dispose = _spine_posed_active_disposePtr
      .asFunction<void Function(spine_posed_active)>();

  bool spine_posed_active_is_active(
    spine_posed_active self,
  ) {
    return _spine_posed_active_is_active(
      self,
    );
  }

  late final _spine_posed_active_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_posed_active)>>(
          'spine_posed_active_is_active');
  late final _spine_posed_active_is_active = _spine_posed_active_is_activePtr
      .asFunction<bool Function(spine_posed_active)>();

  void spine_posed_active_set_active(
    spine_posed_active self,
    bool active,
  ) {
    return _spine_posed_active_set_active(
      self,
      active,
    );
  }

  late final _spine_posed_active_set_activePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_posed_active, ffi.Bool)>>(
      'spine_posed_active_set_active');
  late final _spine_posed_active_set_active = _spine_posed_active_set_activePtr
      .asFunction<void Function(spine_posed_active, bool)>();

  spine_posed_data spine_posed_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_posed_data_create(
      name,
    );
  }

  late final _spine_posed_data_createPtr = _lookup<
          ffi.NativeFunction<spine_posed_data Function(ffi.Pointer<ffi.Char>)>>(
      'spine_posed_data_create');
  late final _spine_posed_data_create = _spine_posed_data_createPtr
      .asFunction<spine_posed_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_posed_data_dispose(
    spine_posed_data self,
  ) {
    return _spine_posed_data_dispose(
      self,
    );
  }

  late final _spine_posed_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_posed_data)>>(
          'spine_posed_data_dispose');
  late final _spine_posed_data_dispose = _spine_posed_data_disposePtr
      .asFunction<void Function(spine_posed_data)>();

  ffi.Pointer<ffi.Char> spine_posed_data_get_name(
    spine_posed_data self,
  ) {
    return _spine_posed_data_get_name(
      self,
    );
  }

  late final _spine_posed_data_get_namePtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_posed_data)>>(
      'spine_posed_data_get_name');
  late final _spine_posed_data_get_name = _spine_posed_data_get_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_posed_data)>();

  bool spine_posed_data_get_skin_required(
    spine_posed_data self,
  ) {
    return _spine_posed_data_get_skin_required(
      self,
    );
  }

  late final _spine_posed_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_posed_data)>>(
          'spine_posed_data_get_skin_required');
  late final _spine_posed_data_get_skin_required =
      _spine_posed_data_get_skin_requiredPtr
          .asFunction<bool Function(spine_posed_data)>();

  void spine_posed_data_set_skin_required(
    spine_posed_data self,
    bool skinRequired,
  ) {
    return _spine_posed_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_posed_data_set_skin_requiredPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_posed_data, ffi.Bool)>>(
      'spine_posed_data_set_skin_required');
  late final _spine_posed_data_set_skin_required =
      _spine_posed_data_set_skin_requiredPtr
          .asFunction<void Function(spine_posed_data, bool)>();

  spine_region_attachment spine_region_attachment_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_region_attachment_create(
      name,
    );
  }

  late final _spine_region_attachment_createPtr = _lookup<
      ffi.NativeFunction<
          spine_region_attachment Function(
              ffi.Pointer<ffi.Char>)>>('spine_region_attachment_create');
  late final _spine_region_attachment_create =
      _spine_region_attachment_createPtr.asFunction<
          spine_region_attachment Function(ffi.Pointer<ffi.Char>)>();

  void spine_region_attachment_dispose(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_dispose(
      self,
    );
  }

  late final _spine_region_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment)>>(
          'spine_region_attachment_dispose');
  late final _spine_region_attachment_dispose =
      _spine_region_attachment_disposePtr
          .asFunction<void Function(spine_region_attachment)>();

  spine_rtti spine_region_attachment_get_rtti(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_rtti(
      self,
    );
  }

  late final _spine_region_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_region_attachment)>>(
          'spine_region_attachment_get_rtti');
  late final _spine_region_attachment_get_rtti =
      _spine_region_attachment_get_rttiPtr
          .asFunction<spine_rtti Function(spine_region_attachment)>();

  void spine_region_attachment_update_region(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_update_region(
      self,
    );
  }

  late final _spine_region_attachment_update_regionPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment)>>(
          'spine_region_attachment_update_region');
  late final _spine_region_attachment_update_region =
      _spine_region_attachment_update_regionPtr
          .asFunction<void Function(spine_region_attachment)>();

  void spine_region_attachment_compute_world_vertices_1(
    spine_region_attachment self,
    spine_slot slot,
    ffi.Pointer<ffi.Float> worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_region_attachment_compute_world_vertices_1(
      self,
      slot,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_region_attachment_compute_world_vertices_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_region_attachment,
              spine_slot,
              ffi.Pointer<ffi.Float>,
              ffi.Size,
              ffi.Size)>>('spine_region_attachment_compute_world_vertices_1');
  late final _spine_region_attachment_compute_world_vertices_1 =
      _spine_region_attachment_compute_world_vertices_1Ptr.asFunction<
          void Function(spine_region_attachment, spine_slot,
              ffi.Pointer<ffi.Float>, int, int)>();

  void spine_region_attachment_compute_world_vertices_2(
    spine_region_attachment self,
    spine_slot slot,
    spine_array_float worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_region_attachment_compute_world_vertices_2(
      self,
      slot,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_region_attachment_compute_world_vertices_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_region_attachment,
              spine_slot,
              spine_array_float,
              ffi.Size,
              ffi.Size)>>('spine_region_attachment_compute_world_vertices_2');
  late final _spine_region_attachment_compute_world_vertices_2 =
      _spine_region_attachment_compute_world_vertices_2Ptr.asFunction<
          void Function(spine_region_attachment, spine_slot, spine_array_float,
              int, int)>();

  double spine_region_attachment_get_x(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_x(
      self,
    );
  }

  late final _spine_region_attachment_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>(
          'spine_region_attachment_get_x');
  late final _spine_region_attachment_get_x = _spine_region_attachment_get_xPtr
      .asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_x(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_x(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_xPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_region_attachment,
              ffi.Float)>>('spine_region_attachment_set_x');
  late final _spine_region_attachment_set_x = _spine_region_attachment_set_xPtr
      .asFunction<void Function(spine_region_attachment, double)>();

  double spine_region_attachment_get_y(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_y(
      self,
    );
  }

  late final _spine_region_attachment_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>(
          'spine_region_attachment_get_y');
  late final _spine_region_attachment_get_y = _spine_region_attachment_get_yPtr
      .asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_y(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_y(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_yPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_region_attachment,
              ffi.Float)>>('spine_region_attachment_set_y');
  late final _spine_region_attachment_set_y = _spine_region_attachment_set_yPtr
      .asFunction<void Function(spine_region_attachment, double)>();

  double spine_region_attachment_get_rotation(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_rotation(
      self,
    );
  }

  late final _spine_region_attachment_get_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>(
          'spine_region_attachment_get_rotation');
  late final _spine_region_attachment_get_rotation =
      _spine_region_attachment_get_rotationPtr
          .asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_rotation(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_rotation(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_rotationPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_region_attachment,
              ffi.Float)>>('spine_region_attachment_set_rotation');
  late final _spine_region_attachment_set_rotation =
      _spine_region_attachment_set_rotationPtr
          .asFunction<void Function(spine_region_attachment, double)>();

  double spine_region_attachment_get_scale_x(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_scale_x(
      self,
    );
  }

  late final _spine_region_attachment_get_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>(
          'spine_region_attachment_get_scale_x');
  late final _spine_region_attachment_get_scale_x =
      _spine_region_attachment_get_scale_xPtr
          .asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_scale_x(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_scale_x(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_scale_xPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_region_attachment,
              ffi.Float)>>('spine_region_attachment_set_scale_x');
  late final _spine_region_attachment_set_scale_x =
      _spine_region_attachment_set_scale_xPtr
          .asFunction<void Function(spine_region_attachment, double)>();

  double spine_region_attachment_get_scale_y(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_scale_y(
      self,
    );
  }

  late final _spine_region_attachment_get_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>(
          'spine_region_attachment_get_scale_y');
  late final _spine_region_attachment_get_scale_y =
      _spine_region_attachment_get_scale_yPtr
          .asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_scale_y(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_scale_y(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_scale_yPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_region_attachment,
              ffi.Float)>>('spine_region_attachment_set_scale_y');
  late final _spine_region_attachment_set_scale_y =
      _spine_region_attachment_set_scale_yPtr
          .asFunction<void Function(spine_region_attachment, double)>();

  double spine_region_attachment_get_width(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_width(
      self,
    );
  }

  late final _spine_region_attachment_get_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>(
          'spine_region_attachment_get_width');
  late final _spine_region_attachment_get_width =
      _spine_region_attachment_get_widthPtr
          .asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_width(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_width(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_widthPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_region_attachment,
              ffi.Float)>>('spine_region_attachment_set_width');
  late final _spine_region_attachment_set_width =
      _spine_region_attachment_set_widthPtr
          .asFunction<void Function(spine_region_attachment, double)>();

  double spine_region_attachment_get_height(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_height(
      self,
    );
  }

  late final _spine_region_attachment_get_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>(
          'spine_region_attachment_get_height');
  late final _spine_region_attachment_get_height =
      _spine_region_attachment_get_heightPtr
          .asFunction<double Function(spine_region_attachment)>();

  void spine_region_attachment_set_height(
    spine_region_attachment self,
    double inValue,
  ) {
    return _spine_region_attachment_set_height(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_heightPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_region_attachment,
              ffi.Float)>>('spine_region_attachment_set_height');
  late final _spine_region_attachment_set_height =
      _spine_region_attachment_set_heightPtr
          .asFunction<void Function(spine_region_attachment, double)>();

  spine_color spine_region_attachment_get_color(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_color(
      self,
    );
  }

  late final _spine_region_attachment_get_colorPtr = _lookup<
          ffi.NativeFunction<spine_color Function(spine_region_attachment)>>(
      'spine_region_attachment_get_color');
  late final _spine_region_attachment_get_color =
      _spine_region_attachment_get_colorPtr
          .asFunction<spine_color Function(spine_region_attachment)>();

  ffi.Pointer<ffi.Char> spine_region_attachment_get_path(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_path(
      self,
    );
  }

  late final _spine_region_attachment_get_pathPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              spine_region_attachment)>>('spine_region_attachment_get_path');
  late final _spine_region_attachment_get_path =
      _spine_region_attachment_get_pathPtr.asFunction<
          ffi.Pointer<ffi.Char> Function(spine_region_attachment)>();

  void spine_region_attachment_set_path(
    spine_region_attachment self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_region_attachment_set_path(
      self,
      inValue,
    );
  }

  late final _spine_region_attachment_set_pathPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_region_attachment,
              ffi.Pointer<ffi.Char>)>>('spine_region_attachment_set_path');
  late final _spine_region_attachment_set_path =
      _spine_region_attachment_set_pathPtr.asFunction<
          void Function(spine_region_attachment, ffi.Pointer<ffi.Char>)>();

  spine_texture_region spine_region_attachment_get_region(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_region(
      self,
    );
  }

  late final _spine_region_attachment_get_regionPtr = _lookup<
      ffi.NativeFunction<
          spine_texture_region Function(
              spine_region_attachment)>>('spine_region_attachment_get_region');
  late final _spine_region_attachment_get_region =
      _spine_region_attachment_get_regionPtr
          .asFunction<spine_texture_region Function(spine_region_attachment)>();

  void spine_region_attachment_set_region(
    spine_region_attachment self,
    spine_texture_region region,
  ) {
    return _spine_region_attachment_set_region(
      self,
      region,
    );
  }

  late final _spine_region_attachment_set_regionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_region_attachment,
              spine_texture_region)>>('spine_region_attachment_set_region');
  late final _spine_region_attachment_set_region =
      _spine_region_attachment_set_regionPtr.asFunction<
          void Function(spine_region_attachment, spine_texture_region)>();

  spine_sequence spine_region_attachment_get_sequence(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_sequence(
      self,
    );
  }

  late final _spine_region_attachment_get_sequencePtr = _lookup<
          ffi.NativeFunction<spine_sequence Function(spine_region_attachment)>>(
      'spine_region_attachment_get_sequence');
  late final _spine_region_attachment_get_sequence =
      _spine_region_attachment_get_sequencePtr
          .asFunction<spine_sequence Function(spine_region_attachment)>();

  void spine_region_attachment_set_sequence(
    spine_region_attachment self,
    spine_sequence sequence,
  ) {
    return _spine_region_attachment_set_sequence(
      self,
      sequence,
    );
  }

  late final _spine_region_attachment_set_sequencePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_region_attachment,
              spine_sequence)>>('spine_region_attachment_set_sequence');
  late final _spine_region_attachment_set_sequence =
      _spine_region_attachment_set_sequencePtr
          .asFunction<void Function(spine_region_attachment, spine_sequence)>();

  spine_array_float spine_region_attachment_get_offset(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_offset(
      self,
    );
  }

  late final _spine_region_attachment_get_offsetPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_region_attachment)>>(
      'spine_region_attachment_get_offset');
  late final _spine_region_attachment_get_offset =
      _spine_region_attachment_get_offsetPtr
          .asFunction<spine_array_float Function(spine_region_attachment)>();

  spine_array_float spine_region_attachment_get_u_vs(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_u_vs(
      self,
    );
  }

  late final _spine_region_attachment_get_u_vsPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_region_attachment)>>(
      'spine_region_attachment_get_u_vs');
  late final _spine_region_attachment_get_u_vs =
      _spine_region_attachment_get_u_vsPtr
          .asFunction<spine_array_float Function(spine_region_attachment)>();

  spine_attachment spine_region_attachment_copy(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_copy(
      self,
    );
  }

  late final _spine_region_attachment_copyPtr = _lookup<
          ffi
          .NativeFunction<spine_attachment Function(spine_region_attachment)>>(
      'spine_region_attachment_copy');
  late final _spine_region_attachment_copy = _spine_region_attachment_copyPtr
      .asFunction<spine_attachment Function(spine_region_attachment)>();

  ffi.Pointer<ffi.Char> spine_region_attachment_get_name(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_name(
      self,
    );
  }

  late final _spine_region_attachment_get_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              spine_region_attachment)>>('spine_region_attachment_get_name');
  late final _spine_region_attachment_get_name =
      _spine_region_attachment_get_namePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(spine_region_attachment)>();

  int spine_region_attachment_get_ref_count(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_region_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_region_attachment)>>(
          'spine_region_attachment_get_ref_count');
  late final _spine_region_attachment_get_ref_count =
      _spine_region_attachment_get_ref_countPtr
          .asFunction<int Function(spine_region_attachment)>();

  void spine_region_attachment_reference(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_reference(
      self,
    );
  }

  late final _spine_region_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment)>>(
          'spine_region_attachment_reference');
  late final _spine_region_attachment_reference =
      _spine_region_attachment_referencePtr
          .asFunction<void Function(spine_region_attachment)>();

  void spine_region_attachment_dereference(
    spine_region_attachment self,
  ) {
    return _spine_region_attachment_dereference(
      self,
    );
  }

  late final _spine_region_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment)>>(
          'spine_region_attachment_dereference');
  late final _spine_region_attachment_dereference =
      _spine_region_attachment_dereferencePtr
          .asFunction<void Function(spine_region_attachment)>();

  spine_rtti spine_region_attachment_rtti() {
    return _spine_region_attachment_rtti();
  }

  late final _spine_region_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_region_attachment_rtti');
  late final _spine_region_attachment_rtti =
      _spine_region_attachment_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_render_command_dispose(
    spine_render_command self,
  ) {
    return _spine_render_command_dispose(
      self,
    );
  }

  late final _spine_render_command_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_render_command)>>(
          'spine_render_command_dispose');
  late final _spine_render_command_dispose = _spine_render_command_disposePtr
      .asFunction<void Function(spine_render_command)>();

  ffi.Pointer<ffi.Float> spine_render_command_get_positions(
    spine_render_command self,
  ) {
    return _spine_render_command_get_positions(
      self,
    );
  }

  late final _spine_render_command_get_positionsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Float> Function(
              spine_render_command)>>('spine_render_command_get_positions');
  late final _spine_render_command_get_positions =
      _spine_render_command_get_positionsPtr
          .asFunction<ffi.Pointer<ffi.Float> Function(spine_render_command)>();

  ffi.Pointer<ffi.Float> spine_render_command_get_uvs(
    spine_render_command self,
  ) {
    return _spine_render_command_get_uvs(
      self,
    );
  }

  late final _spine_render_command_get_uvsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Float> Function(
              spine_render_command)>>('spine_render_command_get_uvs');
  late final _spine_render_command_get_uvs = _spine_render_command_get_uvsPtr
      .asFunction<ffi.Pointer<ffi.Float> Function(spine_render_command)>();

  ffi.Pointer<ffi.Uint32> spine_render_command_get_colors(
    spine_render_command self,
  ) {
    return _spine_render_command_get_colors(
      self,
    );
  }

  late final _spine_render_command_get_colorsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Uint32> Function(
              spine_render_command)>>('spine_render_command_get_colors');
  late final _spine_render_command_get_colors =
      _spine_render_command_get_colorsPtr
          .asFunction<ffi.Pointer<ffi.Uint32> Function(spine_render_command)>();

  ffi.Pointer<ffi.Uint32> spine_render_command_get_dark_colors(
    spine_render_command self,
  ) {
    return _spine_render_command_get_dark_colors(
      self,
    );
  }

  late final _spine_render_command_get_dark_colorsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Uint32> Function(
              spine_render_command)>>('spine_render_command_get_dark_colors');
  late final _spine_render_command_get_dark_colors =
      _spine_render_command_get_dark_colorsPtr
          .asFunction<ffi.Pointer<ffi.Uint32> Function(spine_render_command)>();

  int spine_render_command_get_num_vertices(
    spine_render_command self,
  ) {
    return _spine_render_command_get_num_vertices(
      self,
    );
  }

  late final _spine_render_command_get_num_verticesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_render_command)>>(
          'spine_render_command_get_num_vertices');
  late final _spine_render_command_get_num_vertices =
      _spine_render_command_get_num_verticesPtr
          .asFunction<int Function(spine_render_command)>();

  ffi.Pointer<ffi.Uint16> spine_render_command_get_indices(
    spine_render_command self,
  ) {
    return _spine_render_command_get_indices(
      self,
    );
  }

  late final _spine_render_command_get_indicesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Uint16> Function(
              spine_render_command)>>('spine_render_command_get_indices');
  late final _spine_render_command_get_indices =
      _spine_render_command_get_indicesPtr
          .asFunction<ffi.Pointer<ffi.Uint16> Function(spine_render_command)>();

  int spine_render_command_get_num_indices(
    spine_render_command self,
  ) {
    return _spine_render_command_get_num_indices(
      self,
    );
  }

  late final _spine_render_command_get_num_indicesPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_render_command)>>(
          'spine_render_command_get_num_indices');
  late final _spine_render_command_get_num_indices =
      _spine_render_command_get_num_indicesPtr
          .asFunction<int Function(spine_render_command)>();

  int spine_render_command_get_blend_mode(
    spine_render_command self,
  ) {
    return _spine_render_command_get_blend_mode(
      self,
    );
  }

  late final _spine_render_command_get_blend_modePtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_render_command)>>(
          'spine_render_command_get_blend_mode');
  late final _spine_render_command_get_blend_mode =
      _spine_render_command_get_blend_modePtr
          .asFunction<int Function(spine_render_command)>();

  ffi.Pointer<ffi.Void> spine_render_command_get_texture(
    spine_render_command self,
  ) {
    return _spine_render_command_get_texture(
      self,
    );
  }

  late final _spine_render_command_get_texturePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              spine_render_command)>>('spine_render_command_get_texture');
  late final _spine_render_command_get_texture =
      _spine_render_command_get_texturePtr
          .asFunction<ffi.Pointer<ffi.Void> Function(spine_render_command)>();

  spine_render_command spine_render_command_get_next(
    spine_render_command self,
  ) {
    return _spine_render_command_get_next(
      self,
    );
  }

  late final _spine_render_command_get_nextPtr = _lookup<
          ffi
          .NativeFunction<spine_render_command Function(spine_render_command)>>(
      'spine_render_command_get_next');
  late final _spine_render_command_get_next = _spine_render_command_get_nextPtr
      .asFunction<spine_render_command Function(spine_render_command)>();

  spine_rgb2_timeline spine_rgb2_timeline_create(
    int frameCount,
    int bezierCount,
    int slotIndex,
  ) {
    return _spine_rgb2_timeline_create(
      frameCount,
      bezierCount,
      slotIndex,
    );
  }

  late final _spine_rgb2_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_rgb2_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_rgb2_timeline_create');
  late final _spine_rgb2_timeline_create = _spine_rgb2_timeline_createPtr
      .asFunction<spine_rgb2_timeline Function(int, int, int)>();

  void spine_rgb2_timeline_dispose(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_dispose(
      self,
    );
  }

  late final _spine_rgb2_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgb2_timeline)>>(
          'spine_rgb2_timeline_dispose');
  late final _spine_rgb2_timeline_dispose = _spine_rgb2_timeline_disposePtr
      .asFunction<void Function(spine_rgb2_timeline)>();

  spine_rtti spine_rgb2_timeline_get_rtti(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_rtti(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_rgb2_timeline)>>(
          'spine_rgb2_timeline_get_rtti');
  late final _spine_rgb2_timeline_get_rtti = _spine_rgb2_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_rgb2_timeline)>();

  void spine_rgb2_timeline_set_frame(
    spine_rgb2_timeline self,
    int frame,
    double time,
    double r,
    double g,
    double b,
    double r2,
    double g2,
    double b2,
  ) {
    return _spine_rgb2_timeline_set_frame(
      self,
      frame,
      time,
      r,
      g,
      b,
      r2,
      g2,
      b2,
    );
  }

  late final _spine_rgb2_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_rgb2_timeline,
              ffi.Int,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_rgb2_timeline_set_frame');
  late final _spine_rgb2_timeline_set_frame =
      _spine_rgb2_timeline_set_framePtr.asFunction<
          void Function(spine_rgb2_timeline, int, double, double, double,
              double, double, double, double)>();

  void spine_rgb2_timeline_apply(
    spine_rgb2_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_rgb2_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_rgb2_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_rgb2_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_rgb2_timeline_apply');
  late final _spine_rgb2_timeline_apply =
      _spine_rgb2_timeline_applyPtr.asFunction<
          void Function(spine_rgb2_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_rgb2_timeline_set_linear(
    spine_rgb2_timeline self,
    int frame,
  ) {
    return _spine_rgb2_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_rgb2_timeline_set_linearPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_rgb2_timeline, ffi.Size)>>(
      'spine_rgb2_timeline_set_linear');
  late final _spine_rgb2_timeline_set_linear =
      _spine_rgb2_timeline_set_linearPtr
          .asFunction<void Function(spine_rgb2_timeline, int)>();

  void spine_rgb2_timeline_set_stepped(
    spine_rgb2_timeline self,
    int frame,
  ) {
    return _spine_rgb2_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_rgb2_timeline_set_steppedPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_rgb2_timeline, ffi.Size)>>(
      'spine_rgb2_timeline_set_stepped');
  late final _spine_rgb2_timeline_set_stepped =
      _spine_rgb2_timeline_set_steppedPtr
          .asFunction<void Function(spine_rgb2_timeline, int)>();

  void spine_rgb2_timeline_set_bezier(
    spine_rgb2_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_rgb2_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_rgb2_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_rgb2_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_rgb2_timeline_set_bezier');
  late final _spine_rgb2_timeline_set_bezier =
      _spine_rgb2_timeline_set_bezierPtr.asFunction<
          void Function(spine_rgb2_timeline, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_rgb2_timeline_get_bezier_value(
    spine_rgb2_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_rgb2_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_rgb2_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_rgb2_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_rgb2_timeline_get_bezier_value');
  late final _spine_rgb2_timeline_get_bezier_value =
      _spine_rgb2_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_rgb2_timeline, double, int, int, int)>();

  spine_array_float spine_rgb2_timeline_get_curves(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_curves(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_rgb2_timeline)>>(
      'spine_rgb2_timeline_get_curves');
  late final _spine_rgb2_timeline_get_curves =
      _spine_rgb2_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_rgb2_timeline)>();

  int spine_rgb2_timeline_get_frame_entries(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgb2_timeline)>>(
          'spine_rgb2_timeline_get_frame_entries');
  late final _spine_rgb2_timeline_get_frame_entries =
      _spine_rgb2_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_rgb2_timeline)>();

  int spine_rgb2_timeline_get_frame_count(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgb2_timeline)>>(
          'spine_rgb2_timeline_get_frame_count');
  late final _spine_rgb2_timeline_get_frame_count =
      _spine_rgb2_timeline_get_frame_countPtr
          .asFunction<int Function(spine_rgb2_timeline)>();

  spine_array_float spine_rgb2_timeline_get_frames(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_frames(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_rgb2_timeline)>>(
      'spine_rgb2_timeline_get_frames');
  late final _spine_rgb2_timeline_get_frames =
      _spine_rgb2_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_rgb2_timeline)>();

  double spine_rgb2_timeline_get_duration(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_duration(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rgb2_timeline)>>(
          'spine_rgb2_timeline_get_duration');
  late final _spine_rgb2_timeline_get_duration =
      _spine_rgb2_timeline_get_durationPtr
          .asFunction<double Function(spine_rgb2_timeline)>();

  spine_array_property_id spine_rgb2_timeline_get_property_ids(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_property_idsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_property_id Function(
              spine_rgb2_timeline)>>('spine_rgb2_timeline_get_property_ids');
  late final _spine_rgb2_timeline_get_property_ids =
      _spine_rgb2_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_rgb2_timeline)>();

  int spine_rgb2_timeline_get_slot_index(
    spine_rgb2_timeline self,
  ) {
    return _spine_rgb2_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_rgb2_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_rgb2_timeline)>>(
          'spine_rgb2_timeline_get_slot_index');
  late final _spine_rgb2_timeline_get_slot_index =
      _spine_rgb2_timeline_get_slot_indexPtr
          .asFunction<int Function(spine_rgb2_timeline)>();

  void spine_rgb2_timeline_set_slot_index(
    spine_rgb2_timeline self,
    int inValue,
  ) {
    return _spine_rgb2_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_rgb2_timeline_set_slot_indexPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_rgb2_timeline, ffi.Int)>>(
      'spine_rgb2_timeline_set_slot_index');
  late final _spine_rgb2_timeline_set_slot_index =
      _spine_rgb2_timeline_set_slot_indexPtr
          .asFunction<void Function(spine_rgb2_timeline, int)>();

  spine_rtti spine_rgb2_timeline_rtti() {
    return _spine_rgb2_timeline_rtti();
  }

  late final _spine_rgb2_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_rgb2_timeline_rtti');
  late final _spine_rgb2_timeline_rtti =
      _spine_rgb2_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_rgb_timeline spine_rgb_timeline_create(
    int frameCount,
    int bezierCount,
    int slotIndex,
  ) {
    return _spine_rgb_timeline_create(
      frameCount,
      bezierCount,
      slotIndex,
    );
  }

  late final _spine_rgb_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_rgb_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_rgb_timeline_create');
  late final _spine_rgb_timeline_create = _spine_rgb_timeline_createPtr
      .asFunction<spine_rgb_timeline Function(int, int, int)>();

  void spine_rgb_timeline_dispose(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_dispose(
      self,
    );
  }

  late final _spine_rgb_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgb_timeline)>>(
          'spine_rgb_timeline_dispose');
  late final _spine_rgb_timeline_dispose = _spine_rgb_timeline_disposePtr
      .asFunction<void Function(spine_rgb_timeline)>();

  spine_rtti spine_rgb_timeline_get_rtti(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_rtti(
      self,
    );
  }

  late final _spine_rgb_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_rgb_timeline)>>(
          'spine_rgb_timeline_get_rtti');
  late final _spine_rgb_timeline_get_rtti = _spine_rgb_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_rgb_timeline)>();

  void spine_rgb_timeline_set_frame(
    spine_rgb_timeline self,
    int frame,
    double time,
    double r,
    double g,
    double b,
  ) {
    return _spine_rgb_timeline_set_frame(
      self,
      frame,
      time,
      r,
      g,
      b,
    );
  }

  late final _spine_rgb_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rgb_timeline, ffi.Int, ffi.Float, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_rgb_timeline_set_frame');
  late final _spine_rgb_timeline_set_frame =
      _spine_rgb_timeline_set_framePtr.asFunction<
          void Function(
              spine_rgb_timeline, int, double, double, double, double)>();

  void spine_rgb_timeline_apply(
    spine_rgb_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_rgb_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_rgb_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_rgb_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_rgb_timeline_apply');
  late final _spine_rgb_timeline_apply =
      _spine_rgb_timeline_applyPtr.asFunction<
          void Function(spine_rgb_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_rgb_timeline_set_linear(
    spine_rgb_timeline self,
    int frame,
  ) {
    return _spine_rgb_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_rgb_timeline_set_linearPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_rgb_timeline, ffi.Size)>>(
      'spine_rgb_timeline_set_linear');
  late final _spine_rgb_timeline_set_linear = _spine_rgb_timeline_set_linearPtr
      .asFunction<void Function(spine_rgb_timeline, int)>();

  void spine_rgb_timeline_set_stepped(
    spine_rgb_timeline self,
    int frame,
  ) {
    return _spine_rgb_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_rgb_timeline_set_steppedPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_rgb_timeline, ffi.Size)>>(
      'spine_rgb_timeline_set_stepped');
  late final _spine_rgb_timeline_set_stepped =
      _spine_rgb_timeline_set_steppedPtr
          .asFunction<void Function(spine_rgb_timeline, int)>();

  void spine_rgb_timeline_set_bezier(
    spine_rgb_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_rgb_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_rgb_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_rgb_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_rgb_timeline_set_bezier');
  late final _spine_rgb_timeline_set_bezier =
      _spine_rgb_timeline_set_bezierPtr.asFunction<
          void Function(spine_rgb_timeline, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_rgb_timeline_get_bezier_value(
    spine_rgb_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_rgb_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_rgb_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_rgb_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_rgb_timeline_get_bezier_value');
  late final _spine_rgb_timeline_get_bezier_value =
      _spine_rgb_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_rgb_timeline, double, int, int, int)>();

  spine_array_float spine_rgb_timeline_get_curves(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_curves(
      self,
    );
  }

  late final _spine_rgb_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_rgb_timeline)>>(
      'spine_rgb_timeline_get_curves');
  late final _spine_rgb_timeline_get_curves = _spine_rgb_timeline_get_curvesPtr
      .asFunction<spine_array_float Function(spine_rgb_timeline)>();

  int spine_rgb_timeline_get_frame_entries(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_rgb_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgb_timeline)>>(
          'spine_rgb_timeline_get_frame_entries');
  late final _spine_rgb_timeline_get_frame_entries =
      _spine_rgb_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_rgb_timeline)>();

  int spine_rgb_timeline_get_frame_count(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_rgb_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgb_timeline)>>(
          'spine_rgb_timeline_get_frame_count');
  late final _spine_rgb_timeline_get_frame_count =
      _spine_rgb_timeline_get_frame_countPtr
          .asFunction<int Function(spine_rgb_timeline)>();

  spine_array_float spine_rgb_timeline_get_frames(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_frames(
      self,
    );
  }

  late final _spine_rgb_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_rgb_timeline)>>(
      'spine_rgb_timeline_get_frames');
  late final _spine_rgb_timeline_get_frames = _spine_rgb_timeline_get_framesPtr
      .asFunction<spine_array_float Function(spine_rgb_timeline)>();

  double spine_rgb_timeline_get_duration(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_duration(
      self,
    );
  }

  late final _spine_rgb_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rgb_timeline)>>(
          'spine_rgb_timeline_get_duration');
  late final _spine_rgb_timeline_get_duration =
      _spine_rgb_timeline_get_durationPtr
          .asFunction<double Function(spine_rgb_timeline)>();

  spine_array_property_id spine_rgb_timeline_get_property_ids(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_rgb_timeline_get_property_idsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_property_id Function(
              spine_rgb_timeline)>>('spine_rgb_timeline_get_property_ids');
  late final _spine_rgb_timeline_get_property_ids =
      _spine_rgb_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_rgb_timeline)>();

  int spine_rgb_timeline_get_slot_index(
    spine_rgb_timeline self,
  ) {
    return _spine_rgb_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_rgb_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_rgb_timeline)>>(
          'spine_rgb_timeline_get_slot_index');
  late final _spine_rgb_timeline_get_slot_index =
      _spine_rgb_timeline_get_slot_indexPtr
          .asFunction<int Function(spine_rgb_timeline)>();

  void spine_rgb_timeline_set_slot_index(
    spine_rgb_timeline self,
    int inValue,
  ) {
    return _spine_rgb_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_rgb_timeline_set_slot_indexPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_rgb_timeline, ffi.Int)>>(
      'spine_rgb_timeline_set_slot_index');
  late final _spine_rgb_timeline_set_slot_index =
      _spine_rgb_timeline_set_slot_indexPtr
          .asFunction<void Function(spine_rgb_timeline, int)>();

  spine_rtti spine_rgb_timeline_rtti() {
    return _spine_rgb_timeline_rtti();
  }

  late final _spine_rgb_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_rgb_timeline_rtti');
  late final _spine_rgb_timeline_rtti =
      _spine_rgb_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_rgba2_timeline spine_rgba2_timeline_create(
    int frameCount,
    int bezierCount,
    int slotIndex,
  ) {
    return _spine_rgba2_timeline_create(
      frameCount,
      bezierCount,
      slotIndex,
    );
  }

  late final _spine_rgba2_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_rgba2_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_rgba2_timeline_create');
  late final _spine_rgba2_timeline_create = _spine_rgba2_timeline_createPtr
      .asFunction<spine_rgba2_timeline Function(int, int, int)>();

  void spine_rgba2_timeline_dispose(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_dispose(
      self,
    );
  }

  late final _spine_rgba2_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgba2_timeline)>>(
          'spine_rgba2_timeline_dispose');
  late final _spine_rgba2_timeline_dispose = _spine_rgba2_timeline_disposePtr
      .asFunction<void Function(spine_rgba2_timeline)>();

  spine_rtti spine_rgba2_timeline_get_rtti(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_rtti(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_rgba2_timeline)>>(
          'spine_rgba2_timeline_get_rtti');
  late final _spine_rgba2_timeline_get_rtti = _spine_rgba2_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_rgba2_timeline)>();

  void spine_rgba2_timeline_set_frame(
    spine_rgba2_timeline self,
    int frame,
    double time,
    double r,
    double g,
    double b,
    double a,
    double r2,
    double g2,
    double b2,
  ) {
    return _spine_rgba2_timeline_set_frame(
      self,
      frame,
      time,
      r,
      g,
      b,
      a,
      r2,
      g2,
      b2,
    );
  }

  late final _spine_rgba2_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_rgba2_timeline,
              ffi.Int,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_rgba2_timeline_set_frame');
  late final _spine_rgba2_timeline_set_frame =
      _spine_rgba2_timeline_set_framePtr.asFunction<
          void Function(spine_rgba2_timeline, int, double, double, double,
              double, double, double, double, double)>();

  void spine_rgba2_timeline_apply(
    spine_rgba2_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_rgba2_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_rgba2_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_rgba2_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_rgba2_timeline_apply');
  late final _spine_rgba2_timeline_apply =
      _spine_rgba2_timeline_applyPtr.asFunction<
          void Function(spine_rgba2_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_rgba2_timeline_set_linear(
    spine_rgba2_timeline self,
    int frame,
  ) {
    return _spine_rgba2_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_rgba2_timeline_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_rgba2_timeline, ffi.Size)>>(
      'spine_rgba2_timeline_set_linear');
  late final _spine_rgba2_timeline_set_linear =
      _spine_rgba2_timeline_set_linearPtr
          .asFunction<void Function(spine_rgba2_timeline, int)>();

  void spine_rgba2_timeline_set_stepped(
    spine_rgba2_timeline self,
    int frame,
  ) {
    return _spine_rgba2_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_rgba2_timeline_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_rgba2_timeline, ffi.Size)>>(
      'spine_rgba2_timeline_set_stepped');
  late final _spine_rgba2_timeline_set_stepped =
      _spine_rgba2_timeline_set_steppedPtr
          .asFunction<void Function(spine_rgba2_timeline, int)>();

  void spine_rgba2_timeline_set_bezier(
    spine_rgba2_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_rgba2_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_rgba2_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_rgba2_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_rgba2_timeline_set_bezier');
  late final _spine_rgba2_timeline_set_bezier =
      _spine_rgba2_timeline_set_bezierPtr.asFunction<
          void Function(spine_rgba2_timeline, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_rgba2_timeline_get_bezier_value(
    spine_rgba2_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_rgba2_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_rgba2_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_rgba2_timeline, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_rgba2_timeline_get_bezier_value');
  late final _spine_rgba2_timeline_get_bezier_value =
      _spine_rgba2_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_rgba2_timeline, double, int, int, int)>();

  spine_array_float spine_rgba2_timeline_get_curves(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_curves(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_rgba2_timeline)>>(
      'spine_rgba2_timeline_get_curves');
  late final _spine_rgba2_timeline_get_curves =
      _spine_rgba2_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_rgba2_timeline)>();

  int spine_rgba2_timeline_get_frame_entries(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgba2_timeline)>>(
          'spine_rgba2_timeline_get_frame_entries');
  late final _spine_rgba2_timeline_get_frame_entries =
      _spine_rgba2_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_rgba2_timeline)>();

  int spine_rgba2_timeline_get_frame_count(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgba2_timeline)>>(
          'spine_rgba2_timeline_get_frame_count');
  late final _spine_rgba2_timeline_get_frame_count =
      _spine_rgba2_timeline_get_frame_countPtr
          .asFunction<int Function(spine_rgba2_timeline)>();

  spine_array_float spine_rgba2_timeline_get_frames(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_frames(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_rgba2_timeline)>>(
      'spine_rgba2_timeline_get_frames');
  late final _spine_rgba2_timeline_get_frames =
      _spine_rgba2_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_rgba2_timeline)>();

  double spine_rgba2_timeline_get_duration(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_duration(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rgba2_timeline)>>(
          'spine_rgba2_timeline_get_duration');
  late final _spine_rgba2_timeline_get_duration =
      _spine_rgba2_timeline_get_durationPtr
          .asFunction<double Function(spine_rgba2_timeline)>();

  spine_array_property_id spine_rgba2_timeline_get_property_ids(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_property_idsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_property_id Function(
              spine_rgba2_timeline)>>('spine_rgba2_timeline_get_property_ids');
  late final _spine_rgba2_timeline_get_property_ids =
      _spine_rgba2_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_rgba2_timeline)>();

  int spine_rgba2_timeline_get_slot_index(
    spine_rgba2_timeline self,
  ) {
    return _spine_rgba2_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_rgba2_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_rgba2_timeline)>>(
          'spine_rgba2_timeline_get_slot_index');
  late final _spine_rgba2_timeline_get_slot_index =
      _spine_rgba2_timeline_get_slot_indexPtr
          .asFunction<int Function(spine_rgba2_timeline)>();

  void spine_rgba2_timeline_set_slot_index(
    spine_rgba2_timeline self,
    int inValue,
  ) {
    return _spine_rgba2_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_rgba2_timeline_set_slot_indexPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_rgba2_timeline, ffi.Int)>>(
      'spine_rgba2_timeline_set_slot_index');
  late final _spine_rgba2_timeline_set_slot_index =
      _spine_rgba2_timeline_set_slot_indexPtr
          .asFunction<void Function(spine_rgba2_timeline, int)>();

  spine_rtti spine_rgba2_timeline_rtti() {
    return _spine_rgba2_timeline_rtti();
  }

  late final _spine_rgba2_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_rgba2_timeline_rtti');
  late final _spine_rgba2_timeline_rtti =
      _spine_rgba2_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_rgba_timeline spine_rgba_timeline_create(
    int frameCount,
    int bezierCount,
    int slotIndex,
  ) {
    return _spine_rgba_timeline_create(
      frameCount,
      bezierCount,
      slotIndex,
    );
  }

  late final _spine_rgba_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_rgba_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_rgba_timeline_create');
  late final _spine_rgba_timeline_create = _spine_rgba_timeline_createPtr
      .asFunction<spine_rgba_timeline Function(int, int, int)>();

  void spine_rgba_timeline_dispose(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_dispose(
      self,
    );
  }

  late final _spine_rgba_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rgba_timeline)>>(
          'spine_rgba_timeline_dispose');
  late final _spine_rgba_timeline_dispose = _spine_rgba_timeline_disposePtr
      .asFunction<void Function(spine_rgba_timeline)>();

  spine_rtti spine_rgba_timeline_get_rtti(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_rtti(
      self,
    );
  }

  late final _spine_rgba_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_rgba_timeline)>>(
          'spine_rgba_timeline_get_rtti');
  late final _spine_rgba_timeline_get_rtti = _spine_rgba_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_rgba_timeline)>();

  void spine_rgba_timeline_set_frame(
    spine_rgba_timeline self,
    int frame,
    double time,
    double r,
    double g,
    double b,
    double a,
  ) {
    return _spine_rgba_timeline_set_frame(
      self,
      frame,
      time,
      r,
      g,
      b,
      a,
    );
  }

  late final _spine_rgba_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_rgba_timeline,
              ffi.Int,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_rgba_timeline_set_frame');
  late final _spine_rgba_timeline_set_frame =
      _spine_rgba_timeline_set_framePtr.asFunction<
          void Function(spine_rgba_timeline, int, double, double, double,
              double, double)>();

  void spine_rgba_timeline_apply(
    spine_rgba_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_rgba_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_rgba_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_rgba_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_rgba_timeline_apply');
  late final _spine_rgba_timeline_apply =
      _spine_rgba_timeline_applyPtr.asFunction<
          void Function(spine_rgba_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_rgba_timeline_set_linear(
    spine_rgba_timeline self,
    int frame,
  ) {
    return _spine_rgba_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_rgba_timeline_set_linearPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_rgba_timeline, ffi.Size)>>(
      'spine_rgba_timeline_set_linear');
  late final _spine_rgba_timeline_set_linear =
      _spine_rgba_timeline_set_linearPtr
          .asFunction<void Function(spine_rgba_timeline, int)>();

  void spine_rgba_timeline_set_stepped(
    spine_rgba_timeline self,
    int frame,
  ) {
    return _spine_rgba_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_rgba_timeline_set_steppedPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_rgba_timeline, ffi.Size)>>(
      'spine_rgba_timeline_set_stepped');
  late final _spine_rgba_timeline_set_stepped =
      _spine_rgba_timeline_set_steppedPtr
          .asFunction<void Function(spine_rgba_timeline, int)>();

  void spine_rgba_timeline_set_bezier(
    spine_rgba_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_rgba_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_rgba_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_rgba_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_rgba_timeline_set_bezier');
  late final _spine_rgba_timeline_set_bezier =
      _spine_rgba_timeline_set_bezierPtr.asFunction<
          void Function(spine_rgba_timeline, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_rgba_timeline_get_bezier_value(
    spine_rgba_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_rgba_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_rgba_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_rgba_timeline, ffi.Float, ffi.Size, ffi.Size,
              ffi.Size)>>('spine_rgba_timeline_get_bezier_value');
  late final _spine_rgba_timeline_get_bezier_value =
      _spine_rgba_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_rgba_timeline, double, int, int, int)>();

  spine_array_float spine_rgba_timeline_get_curves(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_curves(
      self,
    );
  }

  late final _spine_rgba_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_rgba_timeline)>>(
      'spine_rgba_timeline_get_curves');
  late final _spine_rgba_timeline_get_curves =
      _spine_rgba_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_rgba_timeline)>();

  int spine_rgba_timeline_get_frame_entries(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_rgba_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgba_timeline)>>(
          'spine_rgba_timeline_get_frame_entries');
  late final _spine_rgba_timeline_get_frame_entries =
      _spine_rgba_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_rgba_timeline)>();

  int spine_rgba_timeline_get_frame_count(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_rgba_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rgba_timeline)>>(
          'spine_rgba_timeline_get_frame_count');
  late final _spine_rgba_timeline_get_frame_count =
      _spine_rgba_timeline_get_frame_countPtr
          .asFunction<int Function(spine_rgba_timeline)>();

  spine_array_float spine_rgba_timeline_get_frames(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_frames(
      self,
    );
  }

  late final _spine_rgba_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_rgba_timeline)>>(
      'spine_rgba_timeline_get_frames');
  late final _spine_rgba_timeline_get_frames =
      _spine_rgba_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_rgba_timeline)>();

  double spine_rgba_timeline_get_duration(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_duration(
      self,
    );
  }

  late final _spine_rgba_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rgba_timeline)>>(
          'spine_rgba_timeline_get_duration');
  late final _spine_rgba_timeline_get_duration =
      _spine_rgba_timeline_get_durationPtr
          .asFunction<double Function(spine_rgba_timeline)>();

  spine_array_property_id spine_rgba_timeline_get_property_ids(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_rgba_timeline_get_property_idsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_property_id Function(
              spine_rgba_timeline)>>('spine_rgba_timeline_get_property_ids');
  late final _spine_rgba_timeline_get_property_ids =
      _spine_rgba_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_rgba_timeline)>();

  int spine_rgba_timeline_get_slot_index(
    spine_rgba_timeline self,
  ) {
    return _spine_rgba_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_rgba_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_rgba_timeline)>>(
          'spine_rgba_timeline_get_slot_index');
  late final _spine_rgba_timeline_get_slot_index =
      _spine_rgba_timeline_get_slot_indexPtr
          .asFunction<int Function(spine_rgba_timeline)>();

  void spine_rgba_timeline_set_slot_index(
    spine_rgba_timeline self,
    int inValue,
  ) {
    return _spine_rgba_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_rgba_timeline_set_slot_indexPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_rgba_timeline, ffi.Int)>>(
      'spine_rgba_timeline_set_slot_index');
  late final _spine_rgba_timeline_set_slot_index =
      _spine_rgba_timeline_set_slot_indexPtr
          .asFunction<void Function(spine_rgba_timeline, int)>();

  spine_rtti spine_rgba_timeline_rtti() {
    return _spine_rgba_timeline_rtti();
  }

  late final _spine_rgba_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_rgba_timeline_rtti');
  late final _spine_rgba_timeline_rtti =
      _spine_rgba_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_rotate_timeline spine_rotate_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_rotate_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_rotate_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_rotate_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_rotate_timeline_create');
  late final _spine_rotate_timeline_create = _spine_rotate_timeline_createPtr
      .asFunction<spine_rotate_timeline Function(int, int, int)>();

  void spine_rotate_timeline_dispose(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_dispose(
      self,
    );
  }

  late final _spine_rotate_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_dispose');
  late final _spine_rotate_timeline_dispose = _spine_rotate_timeline_disposePtr
      .asFunction<void Function(spine_rotate_timeline)>();

  spine_rtti spine_rotate_timeline_get_rtti(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_rtti(
      self,
    );
  }

  late final _spine_rotate_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_get_rtti');
  late final _spine_rotate_timeline_get_rtti =
      _spine_rotate_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_rotate_timeline)>();

  void spine_rotate_timeline_apply(
    spine_rotate_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_rotate_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_rotate_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_rotate_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_rotate_timeline_apply');
  late final _spine_rotate_timeline_apply =
      _spine_rotate_timeline_applyPtr.asFunction<
          void Function(spine_rotate_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_rotate_timeline_set_frame(
    spine_rotate_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_rotate_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_rotate_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_rotate_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_rotate_timeline_set_frame');
  late final _spine_rotate_timeline_set_frame =
      _spine_rotate_timeline_set_framePtr.asFunction<
          void Function(spine_rotate_timeline, int, double, double)>();

  double spine_rotate_timeline_get_curve_value(
    spine_rotate_timeline self,
    double time,
  ) {
    return _spine_rotate_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_rotate_timeline_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_rotate_timeline,
              ffi.Float)>>('spine_rotate_timeline_get_curve_value');
  late final _spine_rotate_timeline_get_curve_value =
      _spine_rotate_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_rotate_timeline, double)>();

  double spine_rotate_timeline_get_relative_value(
    spine_rotate_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_rotate_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_rotate_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_rotate_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_rotate_timeline_get_relative_value');
  late final _spine_rotate_timeline_get_relative_value =
      _spine_rotate_timeline_get_relative_valuePtr.asFunction<
          double Function(
              spine_rotate_timeline, double, double, int, double, double)>();

  double spine_rotate_timeline_get_absolute_value_1(
    spine_rotate_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_rotate_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_rotate_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_rotate_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_rotate_timeline_get_absolute_value_1');
  late final _spine_rotate_timeline_get_absolute_value_1 =
      _spine_rotate_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(
              spine_rotate_timeline, double, double, int, double, double)>();

  double spine_rotate_timeline_get_absolute_value_2(
    spine_rotate_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_rotate_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_rotate_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_rotate_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_rotate_timeline_get_absolute_value_2');
  late final _spine_rotate_timeline_get_absolute_value_2 =
      _spine_rotate_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_rotate_timeline, double, double, int, double,
              double, double)>();

  double spine_rotate_timeline_get_scale_value(
    spine_rotate_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_rotate_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_rotate_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_rotate_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_rotate_timeline_get_scale_value');
  late final _spine_rotate_timeline_get_scale_value =
      _spine_rotate_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_rotate_timeline, double, double, int, int,
              double, double)>();

  void spine_rotate_timeline_set_linear(
    spine_rotate_timeline self,
    int frame,
  ) {
    return _spine_rotate_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_rotate_timeline_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_rotate_timeline, ffi.Size)>>(
      'spine_rotate_timeline_set_linear');
  late final _spine_rotate_timeline_set_linear =
      _spine_rotate_timeline_set_linearPtr
          .asFunction<void Function(spine_rotate_timeline, int)>();

  void spine_rotate_timeline_set_stepped(
    spine_rotate_timeline self,
    int frame,
  ) {
    return _spine_rotate_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_rotate_timeline_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_rotate_timeline, ffi.Size)>>(
      'spine_rotate_timeline_set_stepped');
  late final _spine_rotate_timeline_set_stepped =
      _spine_rotate_timeline_set_steppedPtr
          .asFunction<void Function(spine_rotate_timeline, int)>();

  void spine_rotate_timeline_set_bezier(
    spine_rotate_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_rotate_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_rotate_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_rotate_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_rotate_timeline_set_bezier');
  late final _spine_rotate_timeline_set_bezier =
      _spine_rotate_timeline_set_bezierPtr.asFunction<
          void Function(spine_rotate_timeline, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_rotate_timeline_get_bezier_value(
    spine_rotate_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_rotate_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_rotate_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_rotate_timeline, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_rotate_timeline_get_bezier_value');
  late final _spine_rotate_timeline_get_bezier_value =
      _spine_rotate_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_rotate_timeline, double, int, int, int)>();

  spine_array_float spine_rotate_timeline_get_curves(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_curves(
      self,
    );
  }

  late final _spine_rotate_timeline_get_curvesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_rotate_timeline)>>(
      'spine_rotate_timeline_get_curves');
  late final _spine_rotate_timeline_get_curves =
      _spine_rotate_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_rotate_timeline)>();

  int spine_rotate_timeline_get_frame_entries(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_rotate_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_get_frame_entries');
  late final _spine_rotate_timeline_get_frame_entries =
      _spine_rotate_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_rotate_timeline)>();

  int spine_rotate_timeline_get_frame_count(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_rotate_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_get_frame_count');
  late final _spine_rotate_timeline_get_frame_count =
      _spine_rotate_timeline_get_frame_countPtr
          .asFunction<int Function(spine_rotate_timeline)>();

  spine_array_float spine_rotate_timeline_get_frames(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_frames(
      self,
    );
  }

  late final _spine_rotate_timeline_get_framesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_rotate_timeline)>>(
      'spine_rotate_timeline_get_frames');
  late final _spine_rotate_timeline_get_frames =
      _spine_rotate_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_rotate_timeline)>();

  double spine_rotate_timeline_get_duration(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_duration(
      self,
    );
  }

  late final _spine_rotate_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_get_duration');
  late final _spine_rotate_timeline_get_duration =
      _spine_rotate_timeline_get_durationPtr
          .asFunction<double Function(spine_rotate_timeline)>();

  spine_array_property_id spine_rotate_timeline_get_property_ids(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_rotate_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_rotate_timeline)>>(
      'spine_rotate_timeline_get_property_ids');
  late final _spine_rotate_timeline_get_property_ids =
      _spine_rotate_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_rotate_timeline)>();

  int spine_rotate_timeline_get_bone_index(
    spine_rotate_timeline self,
  ) {
    return _spine_rotate_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_rotate_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_rotate_timeline)>>(
          'spine_rotate_timeline_get_bone_index');
  late final _spine_rotate_timeline_get_bone_index =
      _spine_rotate_timeline_get_bone_indexPtr
          .asFunction<int Function(spine_rotate_timeline)>();

  void spine_rotate_timeline_set_bone_index(
    spine_rotate_timeline self,
    int inValue,
  ) {
    return _spine_rotate_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_rotate_timeline_set_bone_indexPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_rotate_timeline, ffi.Int)>>(
      'spine_rotate_timeline_set_bone_index');
  late final _spine_rotate_timeline_set_bone_index =
      _spine_rotate_timeline_set_bone_indexPtr
          .asFunction<void Function(spine_rotate_timeline, int)>();

  spine_rtti spine_rotate_timeline_rtti() {
    return _spine_rotate_timeline_rtti();
  }

  late final _spine_rotate_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_rotate_timeline_rtti');
  late final _spine_rotate_timeline_rtti =
      _spine_rotate_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_rtti_dispose(
    spine_rtti self,
  ) {
    return _spine_rtti_dispose(
      self,
    );
  }

  late final _spine_rtti_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_rtti)>>(
          'spine_rtti_dispose');
  late final _spine_rtti_dispose =
      _spine_rtti_disposePtr.asFunction<void Function(spine_rtti)>();

  ffi.Pointer<ffi.Char> spine_rtti_get_class_name(
    spine_rtti self,
  ) {
    return _spine_rtti_get_class_name(
      self,
    );
  }

  late final _spine_rtti_get_class_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_rtti)>>(
          'spine_rtti_get_class_name');
  late final _spine_rtti_get_class_name = _spine_rtti_get_class_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_rtti)>();

  bool spine_rtti_is_exactly(
    spine_rtti self,
    spine_rtti rtti,
  ) {
    return _spine_rtti_is_exactly(
      self,
      rtti,
    );
  }

  late final _spine_rtti_is_exactlyPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_rtti, spine_rtti)>>(
          'spine_rtti_is_exactly');
  late final _spine_rtti_is_exactly = _spine_rtti_is_exactlyPtr
      .asFunction<bool Function(spine_rtti, spine_rtti)>();

  bool spine_rtti_instance_of(
    spine_rtti self,
    spine_rtti rtti,
  ) {
    return _spine_rtti_instance_of(
      self,
      rtti,
    );
  }

  late final _spine_rtti_instance_ofPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_rtti, spine_rtti)>>(
          'spine_rtti_instance_of');
  late final _spine_rtti_instance_of = _spine_rtti_instance_ofPtr
      .asFunction<bool Function(spine_rtti, spine_rtti)>();

  spine_scale_timeline spine_scale_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_scale_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_scale_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_scale_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_scale_timeline_create');
  late final _spine_scale_timeline_create = _spine_scale_timeline_createPtr
      .asFunction<spine_scale_timeline Function(int, int, int)>();

  void spine_scale_timeline_dispose(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_dispose(
      self,
    );
  }

  late final _spine_scale_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_timeline)>>(
          'spine_scale_timeline_dispose');
  late final _spine_scale_timeline_dispose = _spine_scale_timeline_disposePtr
      .asFunction<void Function(spine_scale_timeline)>();

  spine_rtti spine_scale_timeline_get_rtti(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_rtti(
      self,
    );
  }

  late final _spine_scale_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_scale_timeline)>>(
          'spine_scale_timeline_get_rtti');
  late final _spine_scale_timeline_get_rtti = _spine_scale_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_scale_timeline)>();

  void spine_scale_timeline_apply(
    spine_scale_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_scale_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_scale_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_scale_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_scale_timeline_apply');
  late final _spine_scale_timeline_apply =
      _spine_scale_timeline_applyPtr.asFunction<
          void Function(spine_scale_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_scale_timeline_set_frame(
    spine_scale_timeline self,
    int frame,
    double time,
    double value1,
    double value2,
  ) {
    return _spine_scale_timeline_set_frame(
      self,
      frame,
      time,
      value1,
      value2,
    );
  }

  late final _spine_scale_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_scale_timeline, ffi.Size, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_scale_timeline_set_frame');
  late final _spine_scale_timeline_set_frame =
      _spine_scale_timeline_set_framePtr.asFunction<
          void Function(spine_scale_timeline, int, double, double, double)>();

  double spine_scale_timeline_get_curve_value(
    spine_scale_timeline self,
    double time,
  ) {
    return _spine_scale_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_scale_timeline_get_curve_valuePtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_scale_timeline, ffi.Float)>>(
      'spine_scale_timeline_get_curve_value');
  late final _spine_scale_timeline_get_curve_value =
      _spine_scale_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_scale_timeline, double)>();

  void spine_scale_timeline_set_linear(
    spine_scale_timeline self,
    int frame,
  ) {
    return _spine_scale_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_scale_timeline_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_scale_timeline, ffi.Size)>>(
      'spine_scale_timeline_set_linear');
  late final _spine_scale_timeline_set_linear =
      _spine_scale_timeline_set_linearPtr
          .asFunction<void Function(spine_scale_timeline, int)>();

  void spine_scale_timeline_set_stepped(
    spine_scale_timeline self,
    int frame,
  ) {
    return _spine_scale_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_scale_timeline_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_scale_timeline, ffi.Size)>>(
      'spine_scale_timeline_set_stepped');
  late final _spine_scale_timeline_set_stepped =
      _spine_scale_timeline_set_steppedPtr
          .asFunction<void Function(spine_scale_timeline, int)>();

  void spine_scale_timeline_set_bezier(
    spine_scale_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_scale_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_scale_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_scale_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_scale_timeline_set_bezier');
  late final _spine_scale_timeline_set_bezier =
      _spine_scale_timeline_set_bezierPtr.asFunction<
          void Function(spine_scale_timeline, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_scale_timeline_get_bezier_value(
    spine_scale_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_scale_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_scale_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_scale_timeline, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_scale_timeline_get_bezier_value');
  late final _spine_scale_timeline_get_bezier_value =
      _spine_scale_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_scale_timeline, double, int, int, int)>();

  spine_array_float spine_scale_timeline_get_curves(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_curves(
      self,
    );
  }

  late final _spine_scale_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_scale_timeline)>>(
      'spine_scale_timeline_get_curves');
  late final _spine_scale_timeline_get_curves =
      _spine_scale_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_scale_timeline)>();

  int spine_scale_timeline_get_frame_entries(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_scale_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_scale_timeline)>>(
          'spine_scale_timeline_get_frame_entries');
  late final _spine_scale_timeline_get_frame_entries =
      _spine_scale_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_scale_timeline)>();

  int spine_scale_timeline_get_frame_count(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_scale_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_scale_timeline)>>(
          'spine_scale_timeline_get_frame_count');
  late final _spine_scale_timeline_get_frame_count =
      _spine_scale_timeline_get_frame_countPtr
          .asFunction<int Function(spine_scale_timeline)>();

  spine_array_float spine_scale_timeline_get_frames(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_frames(
      self,
    );
  }

  late final _spine_scale_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_scale_timeline)>>(
      'spine_scale_timeline_get_frames');
  late final _spine_scale_timeline_get_frames =
      _spine_scale_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_scale_timeline)>();

  double spine_scale_timeline_get_duration(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_duration(
      self,
    );
  }

  late final _spine_scale_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_scale_timeline)>>(
          'spine_scale_timeline_get_duration');
  late final _spine_scale_timeline_get_duration =
      _spine_scale_timeline_get_durationPtr
          .asFunction<double Function(spine_scale_timeline)>();

  spine_array_property_id spine_scale_timeline_get_property_ids(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_scale_timeline_get_property_idsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_property_id Function(
              spine_scale_timeline)>>('spine_scale_timeline_get_property_ids');
  late final _spine_scale_timeline_get_property_ids =
      _spine_scale_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_scale_timeline)>();

  int spine_scale_timeline_get_bone_index(
    spine_scale_timeline self,
  ) {
    return _spine_scale_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_scale_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_scale_timeline)>>(
          'spine_scale_timeline_get_bone_index');
  late final _spine_scale_timeline_get_bone_index =
      _spine_scale_timeline_get_bone_indexPtr
          .asFunction<int Function(spine_scale_timeline)>();

  void spine_scale_timeline_set_bone_index(
    spine_scale_timeline self,
    int inValue,
  ) {
    return _spine_scale_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_scale_timeline_set_bone_indexPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_scale_timeline, ffi.Int)>>(
      'spine_scale_timeline_set_bone_index');
  late final _spine_scale_timeline_set_bone_index =
      _spine_scale_timeline_set_bone_indexPtr
          .asFunction<void Function(spine_scale_timeline, int)>();

  spine_rtti spine_scale_timeline_rtti() {
    return _spine_scale_timeline_rtti();
  }

  late final _spine_scale_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_scale_timeline_rtti');
  late final _spine_scale_timeline_rtti =
      _spine_scale_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_scale_x_timeline spine_scale_x_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_scale_x_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_scale_x_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_scale_x_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_scale_x_timeline_create');
  late final _spine_scale_x_timeline_create = _spine_scale_x_timeline_createPtr
      .asFunction<spine_scale_x_timeline Function(int, int, int)>();

  void spine_scale_x_timeline_dispose(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_dispose(
      self,
    );
  }

  late final _spine_scale_x_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_dispose');
  late final _spine_scale_x_timeline_dispose =
      _spine_scale_x_timeline_disposePtr
          .asFunction<void Function(spine_scale_x_timeline)>();

  spine_rtti spine_scale_x_timeline_get_rtti(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_rtti(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_get_rtti');
  late final _spine_scale_x_timeline_get_rtti =
      _spine_scale_x_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_scale_x_timeline)>();

  void spine_scale_x_timeline_apply(
    spine_scale_x_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_scale_x_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_scale_x_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_scale_x_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_scale_x_timeline_apply');
  late final _spine_scale_x_timeline_apply =
      _spine_scale_x_timeline_applyPtr.asFunction<
          void Function(spine_scale_x_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_scale_x_timeline_set_frame(
    spine_scale_x_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_scale_x_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_scale_x_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_scale_x_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_scale_x_timeline_set_frame');
  late final _spine_scale_x_timeline_set_frame =
      _spine_scale_x_timeline_set_framePtr.asFunction<
          void Function(spine_scale_x_timeline, int, double, double)>();

  double spine_scale_x_timeline_get_curve_value(
    spine_scale_x_timeline self,
    double time,
  ) {
    return _spine_scale_x_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_scale_x_timeline_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_scale_x_timeline,
              ffi.Float)>>('spine_scale_x_timeline_get_curve_value');
  late final _spine_scale_x_timeline_get_curve_value =
      _spine_scale_x_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_scale_x_timeline, double)>();

  double spine_scale_x_timeline_get_relative_value(
    spine_scale_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_scale_x_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_scale_x_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_scale_x_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_scale_x_timeline_get_relative_value');
  late final _spine_scale_x_timeline_get_relative_value =
      _spine_scale_x_timeline_get_relative_valuePtr.asFunction<
          double Function(
              spine_scale_x_timeline, double, double, int, double, double)>();

  double spine_scale_x_timeline_get_absolute_value_1(
    spine_scale_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_scale_x_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_scale_x_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_scale_x_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_scale_x_timeline_get_absolute_value_1');
  late final _spine_scale_x_timeline_get_absolute_value_1 =
      _spine_scale_x_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(
              spine_scale_x_timeline, double, double, int, double, double)>();

  double spine_scale_x_timeline_get_absolute_value_2(
    spine_scale_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_scale_x_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_scale_x_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_scale_x_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_scale_x_timeline_get_absolute_value_2');
  late final _spine_scale_x_timeline_get_absolute_value_2 =
      _spine_scale_x_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_scale_x_timeline, double, double, int, double,
              double, double)>();

  double spine_scale_x_timeline_get_scale_value(
    spine_scale_x_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_scale_x_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_scale_x_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_scale_x_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_scale_x_timeline_get_scale_value');
  late final _spine_scale_x_timeline_get_scale_value =
      _spine_scale_x_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_scale_x_timeline, double, double, int, int,
              double, double)>();

  void spine_scale_x_timeline_set_linear(
    spine_scale_x_timeline self,
    int frame,
  ) {
    return _spine_scale_x_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_scale_x_timeline_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_scale_x_timeline, ffi.Size)>>(
      'spine_scale_x_timeline_set_linear');
  late final _spine_scale_x_timeline_set_linear =
      _spine_scale_x_timeline_set_linearPtr
          .asFunction<void Function(spine_scale_x_timeline, int)>();

  void spine_scale_x_timeline_set_stepped(
    spine_scale_x_timeline self,
    int frame,
  ) {
    return _spine_scale_x_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_scale_x_timeline_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_scale_x_timeline, ffi.Size)>>(
      'spine_scale_x_timeline_set_stepped');
  late final _spine_scale_x_timeline_set_stepped =
      _spine_scale_x_timeline_set_steppedPtr
          .asFunction<void Function(spine_scale_x_timeline, int)>();

  void spine_scale_x_timeline_set_bezier(
    spine_scale_x_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_scale_x_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_scale_x_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_scale_x_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_scale_x_timeline_set_bezier');
  late final _spine_scale_x_timeline_set_bezier =
      _spine_scale_x_timeline_set_bezierPtr.asFunction<
          void Function(spine_scale_x_timeline, int, int, double, double,
              double, double, double, double, double, double, double)>();

  double spine_scale_x_timeline_get_bezier_value(
    spine_scale_x_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_scale_x_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_scale_x_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_scale_x_timeline, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_scale_x_timeline_get_bezier_value');
  late final _spine_scale_x_timeline_get_bezier_value =
      _spine_scale_x_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_scale_x_timeline, double, int, int, int)>();

  spine_array_float spine_scale_x_timeline_get_curves(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_curves(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_curvesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_scale_x_timeline)>>(
      'spine_scale_x_timeline_get_curves');
  late final _spine_scale_x_timeline_get_curves =
      _spine_scale_x_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_scale_x_timeline)>();

  int spine_scale_x_timeline_get_frame_entries(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_get_frame_entries');
  late final _spine_scale_x_timeline_get_frame_entries =
      _spine_scale_x_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_scale_x_timeline)>();

  int spine_scale_x_timeline_get_frame_count(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_get_frame_count');
  late final _spine_scale_x_timeline_get_frame_count =
      _spine_scale_x_timeline_get_frame_countPtr
          .asFunction<int Function(spine_scale_x_timeline)>();

  spine_array_float spine_scale_x_timeline_get_frames(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_frames(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_framesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_scale_x_timeline)>>(
      'spine_scale_x_timeline_get_frames');
  late final _spine_scale_x_timeline_get_frames =
      _spine_scale_x_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_scale_x_timeline)>();

  double spine_scale_x_timeline_get_duration(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_duration(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_get_duration');
  late final _spine_scale_x_timeline_get_duration =
      _spine_scale_x_timeline_get_durationPtr
          .asFunction<double Function(spine_scale_x_timeline)>();

  spine_array_property_id spine_scale_x_timeline_get_property_ids(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_scale_x_timeline)>>(
      'spine_scale_x_timeline_get_property_ids');
  late final _spine_scale_x_timeline_get_property_ids =
      _spine_scale_x_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_scale_x_timeline)>();

  int spine_scale_x_timeline_get_bone_index(
    spine_scale_x_timeline self,
  ) {
    return _spine_scale_x_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_scale_x_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_scale_x_timeline)>>(
          'spine_scale_x_timeline_get_bone_index');
  late final _spine_scale_x_timeline_get_bone_index =
      _spine_scale_x_timeline_get_bone_indexPtr
          .asFunction<int Function(spine_scale_x_timeline)>();

  void spine_scale_x_timeline_set_bone_index(
    spine_scale_x_timeline self,
    int inValue,
  ) {
    return _spine_scale_x_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_scale_x_timeline_set_bone_indexPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_scale_x_timeline, ffi.Int)>>(
      'spine_scale_x_timeline_set_bone_index');
  late final _spine_scale_x_timeline_set_bone_index =
      _spine_scale_x_timeline_set_bone_indexPtr
          .asFunction<void Function(spine_scale_x_timeline, int)>();

  spine_rtti spine_scale_x_timeline_rtti() {
    return _spine_scale_x_timeline_rtti();
  }

  late final _spine_scale_x_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_scale_x_timeline_rtti');
  late final _spine_scale_x_timeline_rtti =
      _spine_scale_x_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_scale_y_timeline spine_scale_y_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_scale_y_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_scale_y_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_scale_y_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_scale_y_timeline_create');
  late final _spine_scale_y_timeline_create = _spine_scale_y_timeline_createPtr
      .asFunction<spine_scale_y_timeline Function(int, int, int)>();

  void spine_scale_y_timeline_dispose(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_dispose(
      self,
    );
  }

  late final _spine_scale_y_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_dispose');
  late final _spine_scale_y_timeline_dispose =
      _spine_scale_y_timeline_disposePtr
          .asFunction<void Function(spine_scale_y_timeline)>();

  spine_rtti spine_scale_y_timeline_get_rtti(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_rtti(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_get_rtti');
  late final _spine_scale_y_timeline_get_rtti =
      _spine_scale_y_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_scale_y_timeline)>();

  void spine_scale_y_timeline_apply(
    spine_scale_y_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_scale_y_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_scale_y_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_scale_y_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_scale_y_timeline_apply');
  late final _spine_scale_y_timeline_apply =
      _spine_scale_y_timeline_applyPtr.asFunction<
          void Function(spine_scale_y_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_scale_y_timeline_set_frame(
    spine_scale_y_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_scale_y_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_scale_y_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_scale_y_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_scale_y_timeline_set_frame');
  late final _spine_scale_y_timeline_set_frame =
      _spine_scale_y_timeline_set_framePtr.asFunction<
          void Function(spine_scale_y_timeline, int, double, double)>();

  double spine_scale_y_timeline_get_curve_value(
    spine_scale_y_timeline self,
    double time,
  ) {
    return _spine_scale_y_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_scale_y_timeline_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_scale_y_timeline,
              ffi.Float)>>('spine_scale_y_timeline_get_curve_value');
  late final _spine_scale_y_timeline_get_curve_value =
      _spine_scale_y_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_scale_y_timeline, double)>();

  double spine_scale_y_timeline_get_relative_value(
    spine_scale_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_scale_y_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_scale_y_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_scale_y_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_scale_y_timeline_get_relative_value');
  late final _spine_scale_y_timeline_get_relative_value =
      _spine_scale_y_timeline_get_relative_valuePtr.asFunction<
          double Function(
              spine_scale_y_timeline, double, double, int, double, double)>();

  double spine_scale_y_timeline_get_absolute_value_1(
    spine_scale_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_scale_y_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_scale_y_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_scale_y_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_scale_y_timeline_get_absolute_value_1');
  late final _spine_scale_y_timeline_get_absolute_value_1 =
      _spine_scale_y_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(
              spine_scale_y_timeline, double, double, int, double, double)>();

  double spine_scale_y_timeline_get_absolute_value_2(
    spine_scale_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_scale_y_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_scale_y_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_scale_y_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_scale_y_timeline_get_absolute_value_2');
  late final _spine_scale_y_timeline_get_absolute_value_2 =
      _spine_scale_y_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_scale_y_timeline, double, double, int, double,
              double, double)>();

  double spine_scale_y_timeline_get_scale_value(
    spine_scale_y_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_scale_y_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_scale_y_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_scale_y_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_scale_y_timeline_get_scale_value');
  late final _spine_scale_y_timeline_get_scale_value =
      _spine_scale_y_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_scale_y_timeline, double, double, int, int,
              double, double)>();

  void spine_scale_y_timeline_set_linear(
    spine_scale_y_timeline self,
    int frame,
  ) {
    return _spine_scale_y_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_scale_y_timeline_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_scale_y_timeline, ffi.Size)>>(
      'spine_scale_y_timeline_set_linear');
  late final _spine_scale_y_timeline_set_linear =
      _spine_scale_y_timeline_set_linearPtr
          .asFunction<void Function(spine_scale_y_timeline, int)>();

  void spine_scale_y_timeline_set_stepped(
    spine_scale_y_timeline self,
    int frame,
  ) {
    return _spine_scale_y_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_scale_y_timeline_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_scale_y_timeline, ffi.Size)>>(
      'spine_scale_y_timeline_set_stepped');
  late final _spine_scale_y_timeline_set_stepped =
      _spine_scale_y_timeline_set_steppedPtr
          .asFunction<void Function(spine_scale_y_timeline, int)>();

  void spine_scale_y_timeline_set_bezier(
    spine_scale_y_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_scale_y_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_scale_y_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_scale_y_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_scale_y_timeline_set_bezier');
  late final _spine_scale_y_timeline_set_bezier =
      _spine_scale_y_timeline_set_bezierPtr.asFunction<
          void Function(spine_scale_y_timeline, int, int, double, double,
              double, double, double, double, double, double, double)>();

  double spine_scale_y_timeline_get_bezier_value(
    spine_scale_y_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_scale_y_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_scale_y_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_scale_y_timeline, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_scale_y_timeline_get_bezier_value');
  late final _spine_scale_y_timeline_get_bezier_value =
      _spine_scale_y_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_scale_y_timeline, double, int, int, int)>();

  spine_array_float spine_scale_y_timeline_get_curves(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_curves(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_curvesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_scale_y_timeline)>>(
      'spine_scale_y_timeline_get_curves');
  late final _spine_scale_y_timeline_get_curves =
      _spine_scale_y_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_scale_y_timeline)>();

  int spine_scale_y_timeline_get_frame_entries(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_get_frame_entries');
  late final _spine_scale_y_timeline_get_frame_entries =
      _spine_scale_y_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_scale_y_timeline)>();

  int spine_scale_y_timeline_get_frame_count(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_get_frame_count');
  late final _spine_scale_y_timeline_get_frame_count =
      _spine_scale_y_timeline_get_frame_countPtr
          .asFunction<int Function(spine_scale_y_timeline)>();

  spine_array_float spine_scale_y_timeline_get_frames(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_frames(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_framesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_scale_y_timeline)>>(
      'spine_scale_y_timeline_get_frames');
  late final _spine_scale_y_timeline_get_frames =
      _spine_scale_y_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_scale_y_timeline)>();

  double spine_scale_y_timeline_get_duration(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_duration(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_get_duration');
  late final _spine_scale_y_timeline_get_duration =
      _spine_scale_y_timeline_get_durationPtr
          .asFunction<double Function(spine_scale_y_timeline)>();

  spine_array_property_id spine_scale_y_timeline_get_property_ids(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_scale_y_timeline)>>(
      'spine_scale_y_timeline_get_property_ids');
  late final _spine_scale_y_timeline_get_property_ids =
      _spine_scale_y_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_scale_y_timeline)>();

  int spine_scale_y_timeline_get_bone_index(
    spine_scale_y_timeline self,
  ) {
    return _spine_scale_y_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_scale_y_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_scale_y_timeline)>>(
          'spine_scale_y_timeline_get_bone_index');
  late final _spine_scale_y_timeline_get_bone_index =
      _spine_scale_y_timeline_get_bone_indexPtr
          .asFunction<int Function(spine_scale_y_timeline)>();

  void spine_scale_y_timeline_set_bone_index(
    spine_scale_y_timeline self,
    int inValue,
  ) {
    return _spine_scale_y_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_scale_y_timeline_set_bone_indexPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_scale_y_timeline, ffi.Int)>>(
      'spine_scale_y_timeline_set_bone_index');
  late final _spine_scale_y_timeline_set_bone_index =
      _spine_scale_y_timeline_set_bone_indexPtr
          .asFunction<void Function(spine_scale_y_timeline, int)>();

  spine_rtti spine_scale_y_timeline_rtti() {
    return _spine_scale_y_timeline_rtti();
  }

  late final _spine_scale_y_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_scale_y_timeline_rtti');
  late final _spine_scale_y_timeline_rtti =
      _spine_scale_y_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_sequence spine_sequence_create(
    int count,
  ) {
    return _spine_sequence_create(
      count,
    );
  }

  late final _spine_sequence_createPtr =
      _lookup<ffi.NativeFunction<spine_sequence Function(ffi.Int)>>(
          'spine_sequence_create');
  late final _spine_sequence_create =
      _spine_sequence_createPtr.asFunction<spine_sequence Function(int)>();

  void spine_sequence_dispose(
    spine_sequence self,
  ) {
    return _spine_sequence_dispose(
      self,
    );
  }

  late final _spine_sequence_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence)>>(
          'spine_sequence_dispose');
  late final _spine_sequence_dispose =
      _spine_sequence_disposePtr.asFunction<void Function(spine_sequence)>();

  spine_sequence spine_sequence_copy(
    spine_sequence self,
  ) {
    return _spine_sequence_copy(
      self,
    );
  }

  late final _spine_sequence_copyPtr =
      _lookup<ffi.NativeFunction<spine_sequence Function(spine_sequence)>>(
          'spine_sequence_copy');
  late final _spine_sequence_copy = _spine_sequence_copyPtr
      .asFunction<spine_sequence Function(spine_sequence)>();

  void spine_sequence_apply(
    spine_sequence self,
    spine_slot_pose slot,
    spine_attachment attachment,
  ) {
    return _spine_sequence_apply(
      self,
      slot,
      attachment,
    );
  }

  late final _spine_sequence_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_sequence, spine_slot_pose,
              spine_attachment)>>('spine_sequence_apply');
  late final _spine_sequence_apply = _spine_sequence_applyPtr.asFunction<
      void Function(spine_sequence, spine_slot_pose, spine_attachment)>();

  ffi.Pointer<ffi.Char> spine_sequence_get_path(
    spine_sequence self,
    ffi.Pointer<ffi.Char> basePath,
    int index,
  ) {
    return _spine_sequence_get_path(
      self,
      basePath,
      index,
    );
  }

  late final _spine_sequence_get_pathPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(spine_sequence, ffi.Pointer<ffi.Char>,
              ffi.Int)>>('spine_sequence_get_path');
  late final _spine_sequence_get_path = _spine_sequence_get_pathPtr.asFunction<
      ffi.Pointer<ffi.Char> Function(
          spine_sequence, ffi.Pointer<ffi.Char>, int)>();

  int spine_sequence_get_id(
    spine_sequence self,
  ) {
    return _spine_sequence_get_id(
      self,
    );
  }

  late final _spine_sequence_get_idPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_sequence)>>(
          'spine_sequence_get_id');
  late final _spine_sequence_get_id =
      _spine_sequence_get_idPtr.asFunction<int Function(spine_sequence)>();

  void spine_sequence_set_id(
    spine_sequence self,
    int id,
  ) {
    return _spine_sequence_set_id(
      self,
      id,
    );
  }

  late final _spine_sequence_set_idPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int)>>(
          'spine_sequence_set_id');
  late final _spine_sequence_set_id = _spine_sequence_set_idPtr
      .asFunction<void Function(spine_sequence, int)>();

  int spine_sequence_get_start(
    spine_sequence self,
  ) {
    return _spine_sequence_get_start(
      self,
    );
  }

  late final _spine_sequence_get_startPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_sequence)>>(
          'spine_sequence_get_start');
  late final _spine_sequence_get_start =
      _spine_sequence_get_startPtr.asFunction<int Function(spine_sequence)>();

  void spine_sequence_set_start(
    spine_sequence self,
    int start,
  ) {
    return _spine_sequence_set_start(
      self,
      start,
    );
  }

  late final _spine_sequence_set_startPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int)>>(
          'spine_sequence_set_start');
  late final _spine_sequence_set_start = _spine_sequence_set_startPtr
      .asFunction<void Function(spine_sequence, int)>();

  int spine_sequence_get_digits(
    spine_sequence self,
  ) {
    return _spine_sequence_get_digits(
      self,
    );
  }

  late final _spine_sequence_get_digitsPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_sequence)>>(
          'spine_sequence_get_digits');
  late final _spine_sequence_get_digits =
      _spine_sequence_get_digitsPtr.asFunction<int Function(spine_sequence)>();

  void spine_sequence_set_digits(
    spine_sequence self,
    int digits,
  ) {
    return _spine_sequence_set_digits(
      self,
      digits,
    );
  }

  late final _spine_sequence_set_digitsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int)>>(
          'spine_sequence_set_digits');
  late final _spine_sequence_set_digits = _spine_sequence_set_digitsPtr
      .asFunction<void Function(spine_sequence, int)>();

  int spine_sequence_get_setup_index(
    spine_sequence self,
  ) {
    return _spine_sequence_get_setup_index(
      self,
    );
  }

  late final _spine_sequence_get_setup_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_sequence)>>(
          'spine_sequence_get_setup_index');
  late final _spine_sequence_get_setup_index =
      _spine_sequence_get_setup_indexPtr
          .asFunction<int Function(spine_sequence)>();

  void spine_sequence_set_setup_index(
    spine_sequence self,
    int setupIndex,
  ) {
    return _spine_sequence_set_setup_index(
      self,
      setupIndex,
    );
  }

  late final _spine_sequence_set_setup_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int)>>(
          'spine_sequence_set_setup_index');
  late final _spine_sequence_set_setup_index =
      _spine_sequence_set_setup_indexPtr
          .asFunction<void Function(spine_sequence, int)>();

  spine_array_texture_region spine_sequence_get_regions(
    spine_sequence self,
  ) {
    return _spine_sequence_get_regions(
      self,
    );
  }

  late final _spine_sequence_get_regionsPtr = _lookup<
          ffi
          .NativeFunction<spine_array_texture_region Function(spine_sequence)>>(
      'spine_sequence_get_regions');
  late final _spine_sequence_get_regions = _spine_sequence_get_regionsPtr
      .asFunction<spine_array_texture_region Function(spine_sequence)>();

  spine_sequence_timeline spine_sequence_timeline_create(
    int frameCount,
    int slotIndex,
    spine_attachment attachment,
  ) {
    return _spine_sequence_timeline_create(
      frameCount,
      slotIndex,
      attachment,
    );
  }

  late final _spine_sequence_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_sequence_timeline Function(ffi.Size, ffi.Int,
              spine_attachment)>>('spine_sequence_timeline_create');
  late final _spine_sequence_timeline_create =
      _spine_sequence_timeline_createPtr.asFunction<
          spine_sequence_timeline Function(int, int, spine_attachment)>();

  void spine_sequence_timeline_dispose(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_dispose(
      self,
    );
  }

  late final _spine_sequence_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence_timeline)>>(
          'spine_sequence_timeline_dispose');
  late final _spine_sequence_timeline_dispose =
      _spine_sequence_timeline_disposePtr
          .asFunction<void Function(spine_sequence_timeline)>();

  spine_rtti spine_sequence_timeline_get_rtti(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_rtti(
      self,
    );
  }

  late final _spine_sequence_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_sequence_timeline)>>(
          'spine_sequence_timeline_get_rtti');
  late final _spine_sequence_timeline_get_rtti =
      _spine_sequence_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_sequence_timeline)>();

  void spine_sequence_timeline_apply(
    spine_sequence_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_sequence_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_sequence_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_sequence_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_sequence_timeline_apply');
  late final _spine_sequence_timeline_apply =
      _spine_sequence_timeline_applyPtr.asFunction<
          void Function(spine_sequence_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_sequence_timeline_set_frame(
    spine_sequence_timeline self,
    int frame,
    double time,
    int mode,
    int index,
    double delay,
  ) {
    return _spine_sequence_timeline_set_frame(
      self,
      frame,
      time,
      mode,
      index,
      delay,
    );
  }

  late final _spine_sequence_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_sequence_timeline,
              ffi.Int,
              ffi.Float,
              ffi.Int32,
              ffi.Int,
              ffi.Float)>>('spine_sequence_timeline_set_frame');
  late final _spine_sequence_timeline_set_frame =
      _spine_sequence_timeline_set_framePtr.asFunction<
          void Function(
              spine_sequence_timeline, int, double, int, int, double)>();

  spine_attachment spine_sequence_timeline_get_attachment(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_attachment(
      self,
    );
  }

  late final _spine_sequence_timeline_get_attachmentPtr = _lookup<
          ffi
          .NativeFunction<spine_attachment Function(spine_sequence_timeline)>>(
      'spine_sequence_timeline_get_attachment');
  late final _spine_sequence_timeline_get_attachment =
      _spine_sequence_timeline_get_attachmentPtr
          .asFunction<spine_attachment Function(spine_sequence_timeline)>();

  int spine_sequence_timeline_get_frame_entries(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_sequence_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_sequence_timeline)>>(
          'spine_sequence_timeline_get_frame_entries');
  late final _spine_sequence_timeline_get_frame_entries =
      _spine_sequence_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_sequence_timeline)>();

  int spine_sequence_timeline_get_frame_count(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_sequence_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_sequence_timeline)>>(
          'spine_sequence_timeline_get_frame_count');
  late final _spine_sequence_timeline_get_frame_count =
      _spine_sequence_timeline_get_frame_countPtr
          .asFunction<int Function(spine_sequence_timeline)>();

  spine_array_float spine_sequence_timeline_get_frames(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_frames(
      self,
    );
  }

  late final _spine_sequence_timeline_get_framesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_sequence_timeline)>>(
      'spine_sequence_timeline_get_frames');
  late final _spine_sequence_timeline_get_frames =
      _spine_sequence_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_sequence_timeline)>();

  double spine_sequence_timeline_get_duration(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_duration(
      self,
    );
  }

  late final _spine_sequence_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_sequence_timeline)>>(
          'spine_sequence_timeline_get_duration');
  late final _spine_sequence_timeline_get_duration =
      _spine_sequence_timeline_get_durationPtr
          .asFunction<double Function(spine_sequence_timeline)>();

  spine_array_property_id spine_sequence_timeline_get_property_ids(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_sequence_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_sequence_timeline)>>(
      'spine_sequence_timeline_get_property_ids');
  late final _spine_sequence_timeline_get_property_ids =
      _spine_sequence_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_sequence_timeline)>();

  int spine_sequence_timeline_get_slot_index(
    spine_sequence_timeline self,
  ) {
    return _spine_sequence_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_sequence_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_sequence_timeline)>>(
          'spine_sequence_timeline_get_slot_index');
  late final _spine_sequence_timeline_get_slot_index =
      _spine_sequence_timeline_get_slot_indexPtr
          .asFunction<int Function(spine_sequence_timeline)>();

  void spine_sequence_timeline_set_slot_index(
    spine_sequence_timeline self,
    int inValue,
  ) {
    return _spine_sequence_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_sequence_timeline_set_slot_indexPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_sequence_timeline, ffi.Int)>>(
      'spine_sequence_timeline_set_slot_index');
  late final _spine_sequence_timeline_set_slot_index =
      _spine_sequence_timeline_set_slot_indexPtr
          .asFunction<void Function(spine_sequence_timeline, int)>();

  spine_rtti spine_sequence_timeline_rtti() {
    return _spine_sequence_timeline_rtti();
  }

  late final _spine_sequence_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_sequence_timeline_rtti');
  late final _spine_sequence_timeline_rtti =
      _spine_sequence_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_shear_timeline spine_shear_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_shear_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_shear_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_shear_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_shear_timeline_create');
  late final _spine_shear_timeline_create = _spine_shear_timeline_createPtr
      .asFunction<spine_shear_timeline Function(int, int, int)>();

  void spine_shear_timeline_dispose(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_dispose(
      self,
    );
  }

  late final _spine_shear_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_timeline)>>(
          'spine_shear_timeline_dispose');
  late final _spine_shear_timeline_dispose = _spine_shear_timeline_disposePtr
      .asFunction<void Function(spine_shear_timeline)>();

  spine_rtti spine_shear_timeline_get_rtti(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_rtti(
      self,
    );
  }

  late final _spine_shear_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_shear_timeline)>>(
          'spine_shear_timeline_get_rtti');
  late final _spine_shear_timeline_get_rtti = _spine_shear_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_shear_timeline)>();

  void spine_shear_timeline_apply(
    spine_shear_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_shear_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_shear_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_shear_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_shear_timeline_apply');
  late final _spine_shear_timeline_apply =
      _spine_shear_timeline_applyPtr.asFunction<
          void Function(spine_shear_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_shear_timeline_set_frame(
    spine_shear_timeline self,
    int frame,
    double time,
    double value1,
    double value2,
  ) {
    return _spine_shear_timeline_set_frame(
      self,
      frame,
      time,
      value1,
      value2,
    );
  }

  late final _spine_shear_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_shear_timeline, ffi.Size, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_shear_timeline_set_frame');
  late final _spine_shear_timeline_set_frame =
      _spine_shear_timeline_set_framePtr.asFunction<
          void Function(spine_shear_timeline, int, double, double, double)>();

  double spine_shear_timeline_get_curve_value(
    spine_shear_timeline self,
    double time,
  ) {
    return _spine_shear_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_shear_timeline_get_curve_valuePtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_shear_timeline, ffi.Float)>>(
      'spine_shear_timeline_get_curve_value');
  late final _spine_shear_timeline_get_curve_value =
      _spine_shear_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_shear_timeline, double)>();

  void spine_shear_timeline_set_linear(
    spine_shear_timeline self,
    int frame,
  ) {
    return _spine_shear_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_shear_timeline_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_shear_timeline, ffi.Size)>>(
      'spine_shear_timeline_set_linear');
  late final _spine_shear_timeline_set_linear =
      _spine_shear_timeline_set_linearPtr
          .asFunction<void Function(spine_shear_timeline, int)>();

  void spine_shear_timeline_set_stepped(
    spine_shear_timeline self,
    int frame,
  ) {
    return _spine_shear_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_shear_timeline_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_shear_timeline, ffi.Size)>>(
      'spine_shear_timeline_set_stepped');
  late final _spine_shear_timeline_set_stepped =
      _spine_shear_timeline_set_steppedPtr
          .asFunction<void Function(spine_shear_timeline, int)>();

  void spine_shear_timeline_set_bezier(
    spine_shear_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_shear_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_shear_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_shear_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_shear_timeline_set_bezier');
  late final _spine_shear_timeline_set_bezier =
      _spine_shear_timeline_set_bezierPtr.asFunction<
          void Function(spine_shear_timeline, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_shear_timeline_get_bezier_value(
    spine_shear_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_shear_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_shear_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_shear_timeline, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_shear_timeline_get_bezier_value');
  late final _spine_shear_timeline_get_bezier_value =
      _spine_shear_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_shear_timeline, double, int, int, int)>();

  spine_array_float spine_shear_timeline_get_curves(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_curves(
      self,
    );
  }

  late final _spine_shear_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_shear_timeline)>>(
      'spine_shear_timeline_get_curves');
  late final _spine_shear_timeline_get_curves =
      _spine_shear_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_shear_timeline)>();

  int spine_shear_timeline_get_frame_entries(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_shear_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_shear_timeline)>>(
          'spine_shear_timeline_get_frame_entries');
  late final _spine_shear_timeline_get_frame_entries =
      _spine_shear_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_shear_timeline)>();

  int spine_shear_timeline_get_frame_count(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_shear_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_shear_timeline)>>(
          'spine_shear_timeline_get_frame_count');
  late final _spine_shear_timeline_get_frame_count =
      _spine_shear_timeline_get_frame_countPtr
          .asFunction<int Function(spine_shear_timeline)>();

  spine_array_float spine_shear_timeline_get_frames(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_frames(
      self,
    );
  }

  late final _spine_shear_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<spine_array_float Function(spine_shear_timeline)>>(
      'spine_shear_timeline_get_frames');
  late final _spine_shear_timeline_get_frames =
      _spine_shear_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_shear_timeline)>();

  double spine_shear_timeline_get_duration(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_duration(
      self,
    );
  }

  late final _spine_shear_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_shear_timeline)>>(
          'spine_shear_timeline_get_duration');
  late final _spine_shear_timeline_get_duration =
      _spine_shear_timeline_get_durationPtr
          .asFunction<double Function(spine_shear_timeline)>();

  spine_array_property_id spine_shear_timeline_get_property_ids(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_shear_timeline_get_property_idsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_property_id Function(
              spine_shear_timeline)>>('spine_shear_timeline_get_property_ids');
  late final _spine_shear_timeline_get_property_ids =
      _spine_shear_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_shear_timeline)>();

  int spine_shear_timeline_get_bone_index(
    spine_shear_timeline self,
  ) {
    return _spine_shear_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_shear_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_shear_timeline)>>(
          'spine_shear_timeline_get_bone_index');
  late final _spine_shear_timeline_get_bone_index =
      _spine_shear_timeline_get_bone_indexPtr
          .asFunction<int Function(spine_shear_timeline)>();

  void spine_shear_timeline_set_bone_index(
    spine_shear_timeline self,
    int inValue,
  ) {
    return _spine_shear_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_shear_timeline_set_bone_indexPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_shear_timeline, ffi.Int)>>(
      'spine_shear_timeline_set_bone_index');
  late final _spine_shear_timeline_set_bone_index =
      _spine_shear_timeline_set_bone_indexPtr
          .asFunction<void Function(spine_shear_timeline, int)>();

  spine_rtti spine_shear_timeline_rtti() {
    return _spine_shear_timeline_rtti();
  }

  late final _spine_shear_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_shear_timeline_rtti');
  late final _spine_shear_timeline_rtti =
      _spine_shear_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_shear_x_timeline spine_shear_x_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_shear_x_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_shear_x_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_shear_x_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_shear_x_timeline_create');
  late final _spine_shear_x_timeline_create = _spine_shear_x_timeline_createPtr
      .asFunction<spine_shear_x_timeline Function(int, int, int)>();

  void spine_shear_x_timeline_dispose(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_dispose(
      self,
    );
  }

  late final _spine_shear_x_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_dispose');
  late final _spine_shear_x_timeline_dispose =
      _spine_shear_x_timeline_disposePtr
          .asFunction<void Function(spine_shear_x_timeline)>();

  spine_rtti spine_shear_x_timeline_get_rtti(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_rtti(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_get_rtti');
  late final _spine_shear_x_timeline_get_rtti =
      _spine_shear_x_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_shear_x_timeline)>();

  void spine_shear_x_timeline_apply(
    spine_shear_x_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_shear_x_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_shear_x_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_shear_x_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_shear_x_timeline_apply');
  late final _spine_shear_x_timeline_apply =
      _spine_shear_x_timeline_applyPtr.asFunction<
          void Function(spine_shear_x_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_shear_x_timeline_set_frame(
    spine_shear_x_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_shear_x_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_shear_x_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_shear_x_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_shear_x_timeline_set_frame');
  late final _spine_shear_x_timeline_set_frame =
      _spine_shear_x_timeline_set_framePtr.asFunction<
          void Function(spine_shear_x_timeline, int, double, double)>();

  double spine_shear_x_timeline_get_curve_value(
    spine_shear_x_timeline self,
    double time,
  ) {
    return _spine_shear_x_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_shear_x_timeline_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_shear_x_timeline,
              ffi.Float)>>('spine_shear_x_timeline_get_curve_value');
  late final _spine_shear_x_timeline_get_curve_value =
      _spine_shear_x_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_shear_x_timeline, double)>();

  double spine_shear_x_timeline_get_relative_value(
    spine_shear_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_shear_x_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_shear_x_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_shear_x_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_shear_x_timeline_get_relative_value');
  late final _spine_shear_x_timeline_get_relative_value =
      _spine_shear_x_timeline_get_relative_valuePtr.asFunction<
          double Function(
              spine_shear_x_timeline, double, double, int, double, double)>();

  double spine_shear_x_timeline_get_absolute_value_1(
    spine_shear_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_shear_x_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_shear_x_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_shear_x_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_shear_x_timeline_get_absolute_value_1');
  late final _spine_shear_x_timeline_get_absolute_value_1 =
      _spine_shear_x_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(
              spine_shear_x_timeline, double, double, int, double, double)>();

  double spine_shear_x_timeline_get_absolute_value_2(
    spine_shear_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_shear_x_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_shear_x_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_shear_x_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_shear_x_timeline_get_absolute_value_2');
  late final _spine_shear_x_timeline_get_absolute_value_2 =
      _spine_shear_x_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_shear_x_timeline, double, double, int, double,
              double, double)>();

  double spine_shear_x_timeline_get_scale_value(
    spine_shear_x_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_shear_x_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_shear_x_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_shear_x_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_shear_x_timeline_get_scale_value');
  late final _spine_shear_x_timeline_get_scale_value =
      _spine_shear_x_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_shear_x_timeline, double, double, int, int,
              double, double)>();

  void spine_shear_x_timeline_set_linear(
    spine_shear_x_timeline self,
    int frame,
  ) {
    return _spine_shear_x_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_shear_x_timeline_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_shear_x_timeline, ffi.Size)>>(
      'spine_shear_x_timeline_set_linear');
  late final _spine_shear_x_timeline_set_linear =
      _spine_shear_x_timeline_set_linearPtr
          .asFunction<void Function(spine_shear_x_timeline, int)>();

  void spine_shear_x_timeline_set_stepped(
    spine_shear_x_timeline self,
    int frame,
  ) {
    return _spine_shear_x_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_shear_x_timeline_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_shear_x_timeline, ffi.Size)>>(
      'spine_shear_x_timeline_set_stepped');
  late final _spine_shear_x_timeline_set_stepped =
      _spine_shear_x_timeline_set_steppedPtr
          .asFunction<void Function(spine_shear_x_timeline, int)>();

  void spine_shear_x_timeline_set_bezier(
    spine_shear_x_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_shear_x_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_shear_x_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_shear_x_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_shear_x_timeline_set_bezier');
  late final _spine_shear_x_timeline_set_bezier =
      _spine_shear_x_timeline_set_bezierPtr.asFunction<
          void Function(spine_shear_x_timeline, int, int, double, double,
              double, double, double, double, double, double, double)>();

  double spine_shear_x_timeline_get_bezier_value(
    spine_shear_x_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_shear_x_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_shear_x_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_shear_x_timeline, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_shear_x_timeline_get_bezier_value');
  late final _spine_shear_x_timeline_get_bezier_value =
      _spine_shear_x_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_shear_x_timeline, double, int, int, int)>();

  spine_array_float spine_shear_x_timeline_get_curves(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_curves(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_curvesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_shear_x_timeline)>>(
      'spine_shear_x_timeline_get_curves');
  late final _spine_shear_x_timeline_get_curves =
      _spine_shear_x_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_shear_x_timeline)>();

  int spine_shear_x_timeline_get_frame_entries(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_get_frame_entries');
  late final _spine_shear_x_timeline_get_frame_entries =
      _spine_shear_x_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_shear_x_timeline)>();

  int spine_shear_x_timeline_get_frame_count(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_get_frame_count');
  late final _spine_shear_x_timeline_get_frame_count =
      _spine_shear_x_timeline_get_frame_countPtr
          .asFunction<int Function(spine_shear_x_timeline)>();

  spine_array_float spine_shear_x_timeline_get_frames(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_frames(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_framesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_shear_x_timeline)>>(
      'spine_shear_x_timeline_get_frames');
  late final _spine_shear_x_timeline_get_frames =
      _spine_shear_x_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_shear_x_timeline)>();

  double spine_shear_x_timeline_get_duration(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_duration(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_get_duration');
  late final _spine_shear_x_timeline_get_duration =
      _spine_shear_x_timeline_get_durationPtr
          .asFunction<double Function(spine_shear_x_timeline)>();

  spine_array_property_id spine_shear_x_timeline_get_property_ids(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_shear_x_timeline)>>(
      'spine_shear_x_timeline_get_property_ids');
  late final _spine_shear_x_timeline_get_property_ids =
      _spine_shear_x_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_shear_x_timeline)>();

  int spine_shear_x_timeline_get_bone_index(
    spine_shear_x_timeline self,
  ) {
    return _spine_shear_x_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_shear_x_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_shear_x_timeline)>>(
          'spine_shear_x_timeline_get_bone_index');
  late final _spine_shear_x_timeline_get_bone_index =
      _spine_shear_x_timeline_get_bone_indexPtr
          .asFunction<int Function(spine_shear_x_timeline)>();

  void spine_shear_x_timeline_set_bone_index(
    spine_shear_x_timeline self,
    int inValue,
  ) {
    return _spine_shear_x_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_shear_x_timeline_set_bone_indexPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_shear_x_timeline, ffi.Int)>>(
      'spine_shear_x_timeline_set_bone_index');
  late final _spine_shear_x_timeline_set_bone_index =
      _spine_shear_x_timeline_set_bone_indexPtr
          .asFunction<void Function(spine_shear_x_timeline, int)>();

  spine_rtti spine_shear_x_timeline_rtti() {
    return _spine_shear_x_timeline_rtti();
  }

  late final _spine_shear_x_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_shear_x_timeline_rtti');
  late final _spine_shear_x_timeline_rtti =
      _spine_shear_x_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_shear_y_timeline spine_shear_y_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_shear_y_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_shear_y_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_shear_y_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_shear_y_timeline_create');
  late final _spine_shear_y_timeline_create = _spine_shear_y_timeline_createPtr
      .asFunction<spine_shear_y_timeline Function(int, int, int)>();

  void spine_shear_y_timeline_dispose(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_dispose(
      self,
    );
  }

  late final _spine_shear_y_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_dispose');
  late final _spine_shear_y_timeline_dispose =
      _spine_shear_y_timeline_disposePtr
          .asFunction<void Function(spine_shear_y_timeline)>();

  spine_rtti spine_shear_y_timeline_get_rtti(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_rtti(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_get_rtti');
  late final _spine_shear_y_timeline_get_rtti =
      _spine_shear_y_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_shear_y_timeline)>();

  void spine_shear_y_timeline_apply(
    spine_shear_y_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_shear_y_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_shear_y_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_shear_y_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_shear_y_timeline_apply');
  late final _spine_shear_y_timeline_apply =
      _spine_shear_y_timeline_applyPtr.asFunction<
          void Function(spine_shear_y_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_shear_y_timeline_set_frame(
    spine_shear_y_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_shear_y_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_shear_y_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_shear_y_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_shear_y_timeline_set_frame');
  late final _spine_shear_y_timeline_set_frame =
      _spine_shear_y_timeline_set_framePtr.asFunction<
          void Function(spine_shear_y_timeline, int, double, double)>();

  double spine_shear_y_timeline_get_curve_value(
    spine_shear_y_timeline self,
    double time,
  ) {
    return _spine_shear_y_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_shear_y_timeline_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_shear_y_timeline,
              ffi.Float)>>('spine_shear_y_timeline_get_curve_value');
  late final _spine_shear_y_timeline_get_curve_value =
      _spine_shear_y_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_shear_y_timeline, double)>();

  double spine_shear_y_timeline_get_relative_value(
    spine_shear_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_shear_y_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_shear_y_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_shear_y_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_shear_y_timeline_get_relative_value');
  late final _spine_shear_y_timeline_get_relative_value =
      _spine_shear_y_timeline_get_relative_valuePtr.asFunction<
          double Function(
              spine_shear_y_timeline, double, double, int, double, double)>();

  double spine_shear_y_timeline_get_absolute_value_1(
    spine_shear_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_shear_y_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_shear_y_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_shear_y_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_shear_y_timeline_get_absolute_value_1');
  late final _spine_shear_y_timeline_get_absolute_value_1 =
      _spine_shear_y_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(
              spine_shear_y_timeline, double, double, int, double, double)>();

  double spine_shear_y_timeline_get_absolute_value_2(
    spine_shear_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_shear_y_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_shear_y_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_shear_y_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_shear_y_timeline_get_absolute_value_2');
  late final _spine_shear_y_timeline_get_absolute_value_2 =
      _spine_shear_y_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_shear_y_timeline, double, double, int, double,
              double, double)>();

  double spine_shear_y_timeline_get_scale_value(
    spine_shear_y_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_shear_y_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_shear_y_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_shear_y_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_shear_y_timeline_get_scale_value');
  late final _spine_shear_y_timeline_get_scale_value =
      _spine_shear_y_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_shear_y_timeline, double, double, int, int,
              double, double)>();

  void spine_shear_y_timeline_set_linear(
    spine_shear_y_timeline self,
    int frame,
  ) {
    return _spine_shear_y_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_shear_y_timeline_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_shear_y_timeline, ffi.Size)>>(
      'spine_shear_y_timeline_set_linear');
  late final _spine_shear_y_timeline_set_linear =
      _spine_shear_y_timeline_set_linearPtr
          .asFunction<void Function(spine_shear_y_timeline, int)>();

  void spine_shear_y_timeline_set_stepped(
    spine_shear_y_timeline self,
    int frame,
  ) {
    return _spine_shear_y_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_shear_y_timeline_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_shear_y_timeline, ffi.Size)>>(
      'spine_shear_y_timeline_set_stepped');
  late final _spine_shear_y_timeline_set_stepped =
      _spine_shear_y_timeline_set_steppedPtr
          .asFunction<void Function(spine_shear_y_timeline, int)>();

  void spine_shear_y_timeline_set_bezier(
    spine_shear_y_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_shear_y_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_shear_y_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_shear_y_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_shear_y_timeline_set_bezier');
  late final _spine_shear_y_timeline_set_bezier =
      _spine_shear_y_timeline_set_bezierPtr.asFunction<
          void Function(spine_shear_y_timeline, int, int, double, double,
              double, double, double, double, double, double, double)>();

  double spine_shear_y_timeline_get_bezier_value(
    spine_shear_y_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_shear_y_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_shear_y_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_shear_y_timeline, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_shear_y_timeline_get_bezier_value');
  late final _spine_shear_y_timeline_get_bezier_value =
      _spine_shear_y_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_shear_y_timeline, double, int, int, int)>();

  spine_array_float spine_shear_y_timeline_get_curves(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_curves(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_curvesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_shear_y_timeline)>>(
      'spine_shear_y_timeline_get_curves');
  late final _spine_shear_y_timeline_get_curves =
      _spine_shear_y_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_shear_y_timeline)>();

  int spine_shear_y_timeline_get_frame_entries(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_get_frame_entries');
  late final _spine_shear_y_timeline_get_frame_entries =
      _spine_shear_y_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_shear_y_timeline)>();

  int spine_shear_y_timeline_get_frame_count(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_get_frame_count');
  late final _spine_shear_y_timeline_get_frame_count =
      _spine_shear_y_timeline_get_frame_countPtr
          .asFunction<int Function(spine_shear_y_timeline)>();

  spine_array_float spine_shear_y_timeline_get_frames(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_frames(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_framesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_shear_y_timeline)>>(
      'spine_shear_y_timeline_get_frames');
  late final _spine_shear_y_timeline_get_frames =
      _spine_shear_y_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_shear_y_timeline)>();

  double spine_shear_y_timeline_get_duration(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_duration(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_get_duration');
  late final _spine_shear_y_timeline_get_duration =
      _spine_shear_y_timeline_get_durationPtr
          .asFunction<double Function(spine_shear_y_timeline)>();

  spine_array_property_id spine_shear_y_timeline_get_property_ids(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_shear_y_timeline)>>(
      'spine_shear_y_timeline_get_property_ids');
  late final _spine_shear_y_timeline_get_property_ids =
      _spine_shear_y_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_shear_y_timeline)>();

  int spine_shear_y_timeline_get_bone_index(
    spine_shear_y_timeline self,
  ) {
    return _spine_shear_y_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_shear_y_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_shear_y_timeline)>>(
          'spine_shear_y_timeline_get_bone_index');
  late final _spine_shear_y_timeline_get_bone_index =
      _spine_shear_y_timeline_get_bone_indexPtr
          .asFunction<int Function(spine_shear_y_timeline)>();

  void spine_shear_y_timeline_set_bone_index(
    spine_shear_y_timeline self,
    int inValue,
  ) {
    return _spine_shear_y_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_shear_y_timeline_set_bone_indexPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_shear_y_timeline, ffi.Int)>>(
      'spine_shear_y_timeline_set_bone_index');
  late final _spine_shear_y_timeline_set_bone_index =
      _spine_shear_y_timeline_set_bone_indexPtr
          .asFunction<void Function(spine_shear_y_timeline, int)>();

  spine_rtti spine_shear_y_timeline_rtti() {
    return _spine_shear_y_timeline_rtti();
  }

  late final _spine_shear_y_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_shear_y_timeline_rtti');
  late final _spine_shear_y_timeline_rtti =
      _spine_shear_y_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_skeleton spine_skeleton_create(
    spine_skeleton_data skeletonData,
  ) {
    return _spine_skeleton_create(
      skeletonData,
    );
  }

  late final _spine_skeleton_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton Function(spine_skeleton_data)>>(
          'spine_skeleton_create');
  late final _spine_skeleton_create = _spine_skeleton_createPtr
      .asFunction<spine_skeleton Function(spine_skeleton_data)>();

  void spine_skeleton_dispose(
    spine_skeleton self,
  ) {
    return _spine_skeleton_dispose(
      self,
    );
  }

  late final _spine_skeleton_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
          'spine_skeleton_dispose');
  late final _spine_skeleton_dispose =
      _spine_skeleton_disposePtr.asFunction<void Function(spine_skeleton)>();

  void spine_skeleton_update_cache(
    spine_skeleton self,
  ) {
    return _spine_skeleton_update_cache(
      self,
    );
  }

  late final _spine_skeleton_update_cachePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
          'spine_skeleton_update_cache');
  late final _spine_skeleton_update_cache = _spine_skeleton_update_cachePtr
      .asFunction<void Function(spine_skeleton)>();

  void spine_skeleton_print_update_cache(
    spine_skeleton self,
  ) {
    return _spine_skeleton_print_update_cache(
      self,
    );
  }

  late final _spine_skeleton_print_update_cachePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
          'spine_skeleton_print_update_cache');
  late final _spine_skeleton_print_update_cache =
      _spine_skeleton_print_update_cachePtr
          .asFunction<void Function(spine_skeleton)>();

  void spine_skeleton_constrained(
    spine_skeleton self,
    spine_posed object,
  ) {
    return _spine_skeleton_constrained(
      self,
      object,
    );
  }

  late final _spine_skeleton_constrainedPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_posed)>>(
      'spine_skeleton_constrained');
  late final _spine_skeleton_constrained = _spine_skeleton_constrainedPtr
      .asFunction<void Function(spine_skeleton, spine_posed)>();

  void spine_skeleton_sort_bone(
    spine_skeleton self,
    spine_bone bone,
  ) {
    return _spine_skeleton_sort_bone(
      self,
      bone,
    );
  }

  late final _spine_skeleton_sort_bonePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_bone)>>(
      'spine_skeleton_sort_bone');
  late final _spine_skeleton_sort_bone = _spine_skeleton_sort_bonePtr
      .asFunction<void Function(spine_skeleton, spine_bone)>();

  void spine_skeleton_sort_reset(
    spine_array_bone bones,
  ) {
    return _spine_skeleton_sort_reset(
      bones,
    );
  }

  late final _spine_skeleton_sort_resetPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_array_bone)>>(
          'spine_skeleton_sort_reset');
  late final _spine_skeleton_sort_reset = _spine_skeleton_sort_resetPtr
      .asFunction<void Function(spine_array_bone)>();

  void spine_skeleton_update_world_transform_1(
    spine_skeleton self,
    int physics,
  ) {
    return _spine_skeleton_update_world_transform_1(
      self,
      physics,
    );
  }

  late final _spine_skeleton_update_world_transform_1Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Int32)>>(
          'spine_skeleton_update_world_transform_1');
  late final _spine_skeleton_update_world_transform_1 =
      _spine_skeleton_update_world_transform_1Ptr
          .asFunction<void Function(spine_skeleton, int)>();

  void spine_skeleton_update_world_transform_2(
    spine_skeleton self,
    int physics,
    spine_bone_pose parent,
  ) {
    return _spine_skeleton_update_world_transform_2(
      self,
      physics,
      parent,
    );
  }

  late final _spine_skeleton_update_world_transform_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton, ffi.Int32,
              spine_bone_pose)>>('spine_skeleton_update_world_transform_2');
  late final _spine_skeleton_update_world_transform_2 =
      _spine_skeleton_update_world_transform_2Ptr
          .asFunction<void Function(spine_skeleton, int, spine_bone_pose)>();

  void spine_skeleton_setup_pose(
    spine_skeleton self,
  ) {
    return _spine_skeleton_setup_pose(
      self,
    );
  }

  late final _spine_skeleton_setup_posePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
          'spine_skeleton_setup_pose');
  late final _spine_skeleton_setup_pose =
      _spine_skeleton_setup_posePtr.asFunction<void Function(spine_skeleton)>();

  void spine_skeleton_setup_pose_bones(
    spine_skeleton self,
  ) {
    return _spine_skeleton_setup_pose_bones(
      self,
    );
  }

  late final _spine_skeleton_setup_pose_bonesPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
          'spine_skeleton_setup_pose_bones');
  late final _spine_skeleton_setup_pose_bones =
      _spine_skeleton_setup_pose_bonesPtr
          .asFunction<void Function(spine_skeleton)>();

  void spine_skeleton_setup_pose_slots(
    spine_skeleton self,
  ) {
    return _spine_skeleton_setup_pose_slots(
      self,
    );
  }

  late final _spine_skeleton_setup_pose_slotsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
          'spine_skeleton_setup_pose_slots');
  late final _spine_skeleton_setup_pose_slots =
      _spine_skeleton_setup_pose_slotsPtr
          .asFunction<void Function(spine_skeleton)>();

  spine_skeleton_data spine_skeleton_get_data(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_data(
      self,
    );
  }

  late final _spine_skeleton_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_data Function(spine_skeleton)>>(
          'spine_skeleton_get_data');
  late final _spine_skeleton_get_data = _spine_skeleton_get_dataPtr
      .asFunction<spine_skeleton_data Function(spine_skeleton)>();

  spine_array_bone spine_skeleton_get_bones(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_bones(
      self,
    );
  }

  late final _spine_skeleton_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_bone Function(spine_skeleton)>>(
          'spine_skeleton_get_bones');
  late final _spine_skeleton_get_bones = _spine_skeleton_get_bonesPtr
      .asFunction<spine_array_bone Function(spine_skeleton)>();

  spine_array_update spine_skeleton_get_update_cache(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_update_cache(
      self,
    );
  }

  late final _spine_skeleton_get_update_cachePtr =
      _lookup<ffi.NativeFunction<spine_array_update Function(spine_skeleton)>>(
          'spine_skeleton_get_update_cache');
  late final _spine_skeleton_get_update_cache =
      _spine_skeleton_get_update_cachePtr
          .asFunction<spine_array_update Function(spine_skeleton)>();

  spine_bone spine_skeleton_get_root_bone(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_root_bone(
      self,
    );
  }

  late final _spine_skeleton_get_root_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_skeleton)>>(
          'spine_skeleton_get_root_bone');
  late final _spine_skeleton_get_root_bone = _spine_skeleton_get_root_bonePtr
      .asFunction<spine_bone Function(spine_skeleton)>();

  spine_bone spine_skeleton_find_bone(
    spine_skeleton self,
    ffi.Pointer<ffi.Char> boneName,
  ) {
    return _spine_skeleton_find_bone(
      self,
      boneName,
    );
  }

  late final _spine_skeleton_find_bonePtr = _lookup<
      ffi.NativeFunction<
          spine_bone Function(spine_skeleton,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_find_bone');
  late final _spine_skeleton_find_bone = _spine_skeleton_find_bonePtr
      .asFunction<spine_bone Function(spine_skeleton, ffi.Pointer<ffi.Char>)>();

  spine_array_slot spine_skeleton_get_slots(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_slots(
      self,
    );
  }

  late final _spine_skeleton_get_slotsPtr =
      _lookup<ffi.NativeFunction<spine_array_slot Function(spine_skeleton)>>(
          'spine_skeleton_get_slots');
  late final _spine_skeleton_get_slots = _spine_skeleton_get_slotsPtr
      .asFunction<spine_array_slot Function(spine_skeleton)>();

  spine_slot spine_skeleton_find_slot(
    spine_skeleton self,
    ffi.Pointer<ffi.Char> slotName,
  ) {
    return _spine_skeleton_find_slot(
      self,
      slotName,
    );
  }

  late final _spine_skeleton_find_slotPtr = _lookup<
      ffi.NativeFunction<
          spine_slot Function(spine_skeleton,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_find_slot');
  late final _spine_skeleton_find_slot = _spine_skeleton_find_slotPtr
      .asFunction<spine_slot Function(spine_skeleton, ffi.Pointer<ffi.Char>)>();

  spine_array_slot spine_skeleton_get_draw_order(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_draw_order(
      self,
    );
  }

  late final _spine_skeleton_get_draw_orderPtr =
      _lookup<ffi.NativeFunction<spine_array_slot Function(spine_skeleton)>>(
          'spine_skeleton_get_draw_order');
  late final _spine_skeleton_get_draw_order = _spine_skeleton_get_draw_orderPtr
      .asFunction<spine_array_slot Function(spine_skeleton)>();

  spine_skin spine_skeleton_get_skin(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_skin(
      self,
    );
  }

  late final _spine_skeleton_get_skinPtr =
      _lookup<ffi.NativeFunction<spine_skin Function(spine_skeleton)>>(
          'spine_skeleton_get_skin');
  late final _spine_skeleton_get_skin = _spine_skeleton_get_skinPtr
      .asFunction<spine_skin Function(spine_skeleton)>();

  void spine_skeleton_set_skin_1(
    spine_skeleton self,
    ffi.Pointer<ffi.Char> skinName,
  ) {
    return _spine_skeleton_set_skin_1(
      self,
      skinName,
    );
  }

  late final _spine_skeleton_set_skin_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_set_skin_1');
  late final _spine_skeleton_set_skin_1 = _spine_skeleton_set_skin_1Ptr
      .asFunction<void Function(spine_skeleton, ffi.Pointer<ffi.Char>)>();

  void spine_skeleton_set_skin_2(
    spine_skeleton self,
    spine_skin newSkin,
  ) {
    return _spine_skeleton_set_skin_2(
      self,
      newSkin,
    );
  }

  late final _spine_skeleton_set_skin_2Ptr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_skin)>>(
      'spine_skeleton_set_skin_2');
  late final _spine_skeleton_set_skin_2 = _spine_skeleton_set_skin_2Ptr
      .asFunction<void Function(spine_skeleton, spine_skin)>();

  spine_attachment spine_skeleton_get_attachment_1(
    spine_skeleton self,
    ffi.Pointer<ffi.Char> slotName,
    ffi.Pointer<ffi.Char> attachmentName,
  ) {
    return _spine_skeleton_get_attachment_1(
      self,
      slotName,
      attachmentName,
    );
  }

  late final _spine_skeleton_get_attachment_1Ptr = _lookup<
      ffi.NativeFunction<
          spine_attachment Function(spine_skeleton, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_get_attachment_1');
  late final _spine_skeleton_get_attachment_1 =
      _spine_skeleton_get_attachment_1Ptr.asFunction<
          spine_attachment Function(
              spine_skeleton, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();

  spine_attachment spine_skeleton_get_attachment_2(
    spine_skeleton self,
    int slotIndex,
    ffi.Pointer<ffi.Char> attachmentName,
  ) {
    return _spine_skeleton_get_attachment_2(
      self,
      slotIndex,
      attachmentName,
    );
  }

  late final _spine_skeleton_get_attachment_2Ptr = _lookup<
      ffi.NativeFunction<
          spine_attachment Function(spine_skeleton, ffi.Int,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_get_attachment_2');
  late final _spine_skeleton_get_attachment_2 =
      _spine_skeleton_get_attachment_2Ptr.asFunction<
          spine_attachment Function(
              spine_skeleton, int, ffi.Pointer<ffi.Char>)>();

  void spine_skeleton_set_attachment(
    spine_skeleton self,
    ffi.Pointer<ffi.Char> slotName,
    ffi.Pointer<ffi.Char> attachmentName,
  ) {
    return _spine_skeleton_set_attachment(
      self,
      slotName,
      attachmentName,
    );
  }

  late final _spine_skeleton_set_attachmentPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton, ffi.Pointer<ffi.Char>,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_set_attachment');
  late final _spine_skeleton_set_attachment =
      _spine_skeleton_set_attachmentPtr.asFunction<
          void Function(
              spine_skeleton, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();

  spine_array_constraint spine_skeleton_get_constraints(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_constraints(
      self,
    );
  }

  late final _spine_skeleton_get_constraintsPtr = _lookup<
          ffi.NativeFunction<spine_array_constraint Function(spine_skeleton)>>(
      'spine_skeleton_get_constraints');
  late final _spine_skeleton_get_constraints =
      _spine_skeleton_get_constraintsPtr
          .asFunction<spine_array_constraint Function(spine_skeleton)>();

  spine_array_physics_constraint spine_skeleton_get_physics_constraints(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_physics_constraints(
      self,
    );
  }

  late final _spine_skeleton_get_physics_constraintsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_physics_constraint Function(
              spine_skeleton)>>('spine_skeleton_get_physics_constraints');
  late final _spine_skeleton_get_physics_constraints =
      _spine_skeleton_get_physics_constraintsPtr.asFunction<
          spine_array_physics_constraint Function(spine_skeleton)>();

  void spine_skeleton_get_bounds_1(
    spine_skeleton self,
    ffi.Pointer<ffi.Float> outX,
    ffi.Pointer<ffi.Float> outY,
    ffi.Pointer<ffi.Float> outWidth,
    ffi.Pointer<ffi.Float> outHeight,
    spine_array_float outVertexBuffer,
  ) {
    return _spine_skeleton_get_bounds_1(
      self,
      outX,
      outY,
      outWidth,
      outHeight,
      outVertexBuffer,
    );
  }

  late final _spine_skeleton_get_bounds_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_skeleton,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>,
              spine_array_float)>>('spine_skeleton_get_bounds_1');
  late final _spine_skeleton_get_bounds_1 =
      _spine_skeleton_get_bounds_1Ptr.asFunction<
          void Function(
              spine_skeleton,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>,
              spine_array_float)>();

  void spine_skeleton_get_bounds_2(
    spine_skeleton self,
    ffi.Pointer<ffi.Float> outX,
    ffi.Pointer<ffi.Float> outY,
    ffi.Pointer<ffi.Float> outWidth,
    ffi.Pointer<ffi.Float> outHeight,
    spine_array_float outVertexBuffer,
    spine_skeleton_clipping clipper,
  ) {
    return _spine_skeleton_get_bounds_2(
      self,
      outX,
      outY,
      outWidth,
      outHeight,
      outVertexBuffer,
      clipper,
    );
  }

  late final _spine_skeleton_get_bounds_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_skeleton,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>,
              spine_array_float,
              spine_skeleton_clipping)>>('spine_skeleton_get_bounds_2');
  late final _spine_skeleton_get_bounds_2 =
      _spine_skeleton_get_bounds_2Ptr.asFunction<
          void Function(
              spine_skeleton,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.Float>,
              spine_array_float,
              spine_skeleton_clipping)>();

  spine_color spine_skeleton_get_color(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_color(
      self,
    );
  }

  late final _spine_skeleton_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_skeleton)>>(
          'spine_skeleton_get_color');
  late final _spine_skeleton_get_color = _spine_skeleton_get_colorPtr
      .asFunction<spine_color Function(spine_skeleton)>();

  void spine_skeleton_set_color_1(
    spine_skeleton self,
    spine_color color,
  ) {
    return _spine_skeleton_set_color_1(
      self,
      color,
    );
  }

  late final _spine_skeleton_set_color_1Ptr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_color)>>(
      'spine_skeleton_set_color_1');
  late final _spine_skeleton_set_color_1 = _spine_skeleton_set_color_1Ptr
      .asFunction<void Function(spine_skeleton, spine_color)>();

  void spine_skeleton_set_color_2(
    spine_skeleton self,
    double r,
    double g,
    double b,
    double a,
  ) {
    return _spine_skeleton_set_color_2(
      self,
      r,
      g,
      b,
      a,
    );
  }

  late final _spine_skeleton_set_color_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton, ffi.Float, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_skeleton_set_color_2');
  late final _spine_skeleton_set_color_2 =
      _spine_skeleton_set_color_2Ptr.asFunction<
          void Function(spine_skeleton, double, double, double, double)>();

  double spine_skeleton_get_scale_x(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_scale_x(
      self,
    );
  }

  late final _spine_skeleton_get_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
          'spine_skeleton_get_scale_x');
  late final _spine_skeleton_get_scale_x = _spine_skeleton_get_scale_xPtr
      .asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_scale_x(
    spine_skeleton self,
    double inValue,
  ) {
    return _spine_skeleton_set_scale_x(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_set_scale_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
          'spine_skeleton_set_scale_x');
  late final _spine_skeleton_set_scale_x = _spine_skeleton_set_scale_xPtr
      .asFunction<void Function(spine_skeleton, double)>();

  double spine_skeleton_get_scale_y(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_scale_y(
      self,
    );
  }

  late final _spine_skeleton_get_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
          'spine_skeleton_get_scale_y');
  late final _spine_skeleton_get_scale_y = _spine_skeleton_get_scale_yPtr
      .asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_scale_y(
    spine_skeleton self,
    double inValue,
  ) {
    return _spine_skeleton_set_scale_y(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_set_scale_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
          'spine_skeleton_set_scale_y');
  late final _spine_skeleton_set_scale_y = _spine_skeleton_set_scale_yPtr
      .asFunction<void Function(spine_skeleton, double)>();

  void spine_skeleton_set_scale(
    spine_skeleton self,
    double scaleX,
    double scaleY,
  ) {
    return _spine_skeleton_set_scale(
      self,
      scaleX,
      scaleY,
    );
  }

  late final _spine_skeleton_set_scalePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton, ffi.Float,
              ffi.Float)>>('spine_skeleton_set_scale');
  late final _spine_skeleton_set_scale = _spine_skeleton_set_scalePtr
      .asFunction<void Function(spine_skeleton, double, double)>();

  double spine_skeleton_get_x(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_x(
      self,
    );
  }

  late final _spine_skeleton_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
          'spine_skeleton_get_x');
  late final _spine_skeleton_get_x =
      _spine_skeleton_get_xPtr.asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_x(
    spine_skeleton self,
    double inValue,
  ) {
    return _spine_skeleton_set_x(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_set_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
          'spine_skeleton_set_x');
  late final _spine_skeleton_set_x = _spine_skeleton_set_xPtr
      .asFunction<void Function(spine_skeleton, double)>();

  double spine_skeleton_get_y(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_y(
      self,
    );
  }

  late final _spine_skeleton_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
          'spine_skeleton_get_y');
  late final _spine_skeleton_get_y =
      _spine_skeleton_get_yPtr.asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_y(
    spine_skeleton self,
    double inValue,
  ) {
    return _spine_skeleton_set_y(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_set_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
          'spine_skeleton_set_y');
  late final _spine_skeleton_set_y = _spine_skeleton_set_yPtr
      .asFunction<void Function(spine_skeleton, double)>();

  void spine_skeleton_set_position(
    spine_skeleton self,
    double x,
    double y,
  ) {
    return _spine_skeleton_set_position(
      self,
      x,
      y,
    );
  }

  late final _spine_skeleton_set_positionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton, ffi.Float,
              ffi.Float)>>('spine_skeleton_set_position');
  late final _spine_skeleton_set_position = _spine_skeleton_set_positionPtr
      .asFunction<void Function(spine_skeleton, double, double)>();

  double spine_skeleton_get_wind_x(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_wind_x(
      self,
    );
  }

  late final _spine_skeleton_get_wind_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
          'spine_skeleton_get_wind_x');
  late final _spine_skeleton_get_wind_x = _spine_skeleton_get_wind_xPtr
      .asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_wind_x(
    spine_skeleton self,
    double windX,
  ) {
    return _spine_skeleton_set_wind_x(
      self,
      windX,
    );
  }

  late final _spine_skeleton_set_wind_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
          'spine_skeleton_set_wind_x');
  late final _spine_skeleton_set_wind_x = _spine_skeleton_set_wind_xPtr
      .asFunction<void Function(spine_skeleton, double)>();

  double spine_skeleton_get_wind_y(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_wind_y(
      self,
    );
  }

  late final _spine_skeleton_get_wind_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
          'spine_skeleton_get_wind_y');
  late final _spine_skeleton_get_wind_y = _spine_skeleton_get_wind_yPtr
      .asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_wind_y(
    spine_skeleton self,
    double windY,
  ) {
    return _spine_skeleton_set_wind_y(
      self,
      windY,
    );
  }

  late final _spine_skeleton_set_wind_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
          'spine_skeleton_set_wind_y');
  late final _spine_skeleton_set_wind_y = _spine_skeleton_set_wind_yPtr
      .asFunction<void Function(spine_skeleton, double)>();

  double spine_skeleton_get_gravity_x(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_gravity_x(
      self,
    );
  }

  late final _spine_skeleton_get_gravity_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
          'spine_skeleton_get_gravity_x');
  late final _spine_skeleton_get_gravity_x = _spine_skeleton_get_gravity_xPtr
      .asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_gravity_x(
    spine_skeleton self,
    double gravityX,
  ) {
    return _spine_skeleton_set_gravity_x(
      self,
      gravityX,
    );
  }

  late final _spine_skeleton_set_gravity_xPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
          'spine_skeleton_set_gravity_x');
  late final _spine_skeleton_set_gravity_x = _spine_skeleton_set_gravity_xPtr
      .asFunction<void Function(spine_skeleton, double)>();

  double spine_skeleton_get_gravity_y(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_gravity_y(
      self,
    );
  }

  late final _spine_skeleton_get_gravity_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
          'spine_skeleton_get_gravity_y');
  late final _spine_skeleton_get_gravity_y = _spine_skeleton_get_gravity_yPtr
      .asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_gravity_y(
    spine_skeleton self,
    double gravityY,
  ) {
    return _spine_skeleton_set_gravity_y(
      self,
      gravityY,
    );
  }

  late final _spine_skeleton_set_gravity_yPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
          'spine_skeleton_set_gravity_y');
  late final _spine_skeleton_set_gravity_y = _spine_skeleton_set_gravity_yPtr
      .asFunction<void Function(spine_skeleton, double)>();

  void spine_skeleton_physics_translate(
    spine_skeleton self,
    double x,
    double y,
  ) {
    return _spine_skeleton_physics_translate(
      self,
      x,
      y,
    );
  }

  late final _spine_skeleton_physics_translatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton, ffi.Float,
              ffi.Float)>>('spine_skeleton_physics_translate');
  late final _spine_skeleton_physics_translate =
      _spine_skeleton_physics_translatePtr
          .asFunction<void Function(spine_skeleton, double, double)>();

  void spine_skeleton_physics_rotate(
    spine_skeleton self,
    double x,
    double y,
    double degrees,
  ) {
    return _spine_skeleton_physics_rotate(
      self,
      x,
      y,
      degrees,
    );
  }

  late final _spine_skeleton_physics_rotatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton, ffi.Float, ffi.Float,
              ffi.Float)>>('spine_skeleton_physics_rotate');
  late final _spine_skeleton_physics_rotate = _spine_skeleton_physics_rotatePtr
      .asFunction<void Function(spine_skeleton, double, double, double)>();

  double spine_skeleton_get_time(
    spine_skeleton self,
  ) {
    return _spine_skeleton_get_time(
      self,
    );
  }

  late final _spine_skeleton_get_timePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
          'spine_skeleton_get_time');
  late final _spine_skeleton_get_time =
      _spine_skeleton_get_timePtr.asFunction<double Function(spine_skeleton)>();

  void spine_skeleton_set_time(
    spine_skeleton self,
    double time,
  ) {
    return _spine_skeleton_set_time(
      self,
      time,
    );
  }

  late final _spine_skeleton_set_timePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
          'spine_skeleton_set_time');
  late final _spine_skeleton_set_time = _spine_skeleton_set_timePtr
      .asFunction<void Function(spine_skeleton, double)>();

  void spine_skeleton_update(
    spine_skeleton self,
    double delta,
  ) {
    return _spine_skeleton_update(
      self,
      delta,
    );
  }

  late final _spine_skeleton_updatePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
          'spine_skeleton_update');
  late final _spine_skeleton_update = _spine_skeleton_updatePtr
      .asFunction<void Function(spine_skeleton, double)>();

  spine_skeleton_binary spine_skeleton_binary_create(
    spine_atlas atlas,
  ) {
    return _spine_skeleton_binary_create(
      atlas,
    );
  }

  late final _spine_skeleton_binary_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_binary Function(spine_atlas)>>(
          'spine_skeleton_binary_create');
  late final _spine_skeleton_binary_create = _spine_skeleton_binary_createPtr
      .asFunction<spine_skeleton_binary Function(spine_atlas)>();

  spine_skeleton_binary spine_skeleton_binary_create2(
    spine_attachment_loader attachmentLoader,
    bool ownsLoader,
  ) {
    return _spine_skeleton_binary_create2(
      attachmentLoader,
      ownsLoader,
    );
  }

  late final _spine_skeleton_binary_create2Ptr = _lookup<
      ffi.NativeFunction<
          spine_skeleton_binary Function(spine_attachment_loader,
              ffi.Bool)>>('spine_skeleton_binary_create2');
  late final _spine_skeleton_binary_create2 =
      _spine_skeleton_binary_create2Ptr.asFunction<
          spine_skeleton_binary Function(spine_attachment_loader, bool)>();

  void spine_skeleton_binary_dispose(
    spine_skeleton_binary self,
  ) {
    return _spine_skeleton_binary_dispose(
      self,
    );
  }

  late final _spine_skeleton_binary_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_binary)>>(
          'spine_skeleton_binary_dispose');
  late final _spine_skeleton_binary_dispose = _spine_skeleton_binary_disposePtr
      .asFunction<void Function(spine_skeleton_binary)>();

  spine_skeleton_data spine_skeleton_binary_read_skeleton_data(
    spine_skeleton_binary self,
    ffi.Pointer<ffi.UnsignedChar> binary,
    int length,
  ) {
    return _spine_skeleton_binary_read_skeleton_data(
      self,
      binary,
      length,
    );
  }

  late final _spine_skeleton_binary_read_skeleton_dataPtr = _lookup<
      ffi.NativeFunction<
          spine_skeleton_data Function(
              spine_skeleton_binary,
              ffi.Pointer<ffi.UnsignedChar>,
              ffi.Int)>>('spine_skeleton_binary_read_skeleton_data');
  late final _spine_skeleton_binary_read_skeleton_data =
      _spine_skeleton_binary_read_skeleton_dataPtr.asFunction<
          spine_skeleton_data Function(
              spine_skeleton_binary, ffi.Pointer<ffi.UnsignedChar>, int)>();

  spine_skeleton_data spine_skeleton_binary_read_skeleton_data_file(
    spine_skeleton_binary self,
    ffi.Pointer<ffi.Char> path,
  ) {
    return _spine_skeleton_binary_read_skeleton_data_file(
      self,
      path,
    );
  }

  late final _spine_skeleton_binary_read_skeleton_data_filePtr = _lookup<
          ffi.NativeFunction<
              spine_skeleton_data Function(
                  spine_skeleton_binary, ffi.Pointer<ffi.Char>)>>(
      'spine_skeleton_binary_read_skeleton_data_file');
  late final _spine_skeleton_binary_read_skeleton_data_file =
      _spine_skeleton_binary_read_skeleton_data_filePtr.asFunction<
          spine_skeleton_data Function(
              spine_skeleton_binary, ffi.Pointer<ffi.Char>)>();

  void spine_skeleton_binary_set_scale(
    spine_skeleton_binary self,
    double scale,
  ) {
    return _spine_skeleton_binary_set_scale(
      self,
      scale,
    );
  }

  late final _spine_skeleton_binary_set_scalePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_skeleton_binary, ffi.Float)>>(
      'spine_skeleton_binary_set_scale');
  late final _spine_skeleton_binary_set_scale =
      _spine_skeleton_binary_set_scalePtr
          .asFunction<void Function(spine_skeleton_binary, double)>();

  ffi.Pointer<ffi.Char> spine_skeleton_binary_get_error(
    spine_skeleton_binary self,
  ) {
    return _spine_skeleton_binary_get_error(
      self,
    );
  }

  late final _spine_skeleton_binary_get_errorPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              spine_skeleton_binary)>>('spine_skeleton_binary_get_error');
  late final _spine_skeleton_binary_get_error =
      _spine_skeleton_binary_get_errorPtr
          .asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_binary)>();

  spine_skeleton_bounds spine_skeleton_bounds_create() {
    return _spine_skeleton_bounds_create();
  }

  late final _spine_skeleton_bounds_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_bounds Function()>>(
          'spine_skeleton_bounds_create');
  late final _spine_skeleton_bounds_create = _spine_skeleton_bounds_createPtr
      .asFunction<spine_skeleton_bounds Function()>();

  void spine_skeleton_bounds_dispose(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_dispose(
      self,
    );
  }

  late final _spine_skeleton_bounds_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_bounds)>>(
          'spine_skeleton_bounds_dispose');
  late final _spine_skeleton_bounds_dispose = _spine_skeleton_bounds_disposePtr
      .asFunction<void Function(spine_skeleton_bounds)>();

  void spine_skeleton_bounds_update(
    spine_skeleton_bounds self,
    spine_skeleton skeleton,
    bool updateAabb,
  ) {
    return _spine_skeleton_bounds_update(
      self,
      skeleton,
      updateAabb,
    );
  }

  late final _spine_skeleton_bounds_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton_bounds, spine_skeleton,
              ffi.Bool)>>('spine_skeleton_bounds_update');
  late final _spine_skeleton_bounds_update = _spine_skeleton_bounds_updatePtr
      .asFunction<void Function(spine_skeleton_bounds, spine_skeleton, bool)>();

  bool spine_skeleton_bounds_aabb_contains_point(
    spine_skeleton_bounds self,
    double x,
    double y,
  ) {
    return _spine_skeleton_bounds_aabb_contains_point(
      self,
      x,
      y,
    );
  }

  late final _spine_skeleton_bounds_aabb_contains_pointPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(spine_skeleton_bounds, ffi.Float,
              ffi.Float)>>('spine_skeleton_bounds_aabb_contains_point');
  late final _spine_skeleton_bounds_aabb_contains_point =
      _spine_skeleton_bounds_aabb_contains_pointPtr
          .asFunction<bool Function(spine_skeleton_bounds, double, double)>();

  bool spine_skeleton_bounds_aabb_intersects_segment(
    spine_skeleton_bounds self,
    double x1,
    double y1,
    double x2,
    double y2,
  ) {
    return _spine_skeleton_bounds_aabb_intersects_segment(
      self,
      x1,
      y1,
      x2,
      y2,
    );
  }

  late final _spine_skeleton_bounds_aabb_intersects_segmentPtr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              spine_skeleton_bounds,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_skeleton_bounds_aabb_intersects_segment');
  late final _spine_skeleton_bounds_aabb_intersects_segment =
      _spine_skeleton_bounds_aabb_intersects_segmentPtr.asFunction<
          bool Function(
              spine_skeleton_bounds, double, double, double, double)>();

  bool spine_skeleton_bounds_aabb_intersects_skeleton(
    spine_skeleton_bounds self,
    spine_skeleton_bounds bounds,
  ) {
    return _spine_skeleton_bounds_aabb_intersects_skeleton(
      self,
      bounds,
    );
  }

  late final _spine_skeleton_bounds_aabb_intersects_skeletonPtr = _lookup<
          ffi.NativeFunction<
              ffi.Bool Function(spine_skeleton_bounds, spine_skeleton_bounds)>>(
      'spine_skeleton_bounds_aabb_intersects_skeleton');
  late final _spine_skeleton_bounds_aabb_intersects_skeleton =
      _spine_skeleton_bounds_aabb_intersects_skeletonPtr.asFunction<
          bool Function(spine_skeleton_bounds, spine_skeleton_bounds)>();

  bool spine_skeleton_bounds_contains_point_1(
    spine_skeleton_bounds self,
    spine_polygon polygon,
    double x,
    double y,
  ) {
    return _spine_skeleton_bounds_contains_point_1(
      self,
      polygon,
      x,
      y,
    );
  }

  late final _spine_skeleton_bounds_contains_point_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(spine_skeleton_bounds, spine_polygon, ffi.Float,
              ffi.Float)>>('spine_skeleton_bounds_contains_point_1');
  late final _spine_skeleton_bounds_contains_point_1 =
      _spine_skeleton_bounds_contains_point_1Ptr.asFunction<
          bool Function(
              spine_skeleton_bounds, spine_polygon, double, double)>();

  spine_bounding_box_attachment spine_skeleton_bounds_contains_point_2(
    spine_skeleton_bounds self,
    double x,
    double y,
  ) {
    return _spine_skeleton_bounds_contains_point_2(
      self,
      x,
      y,
    );
  }

  late final _spine_skeleton_bounds_contains_point_2Ptr = _lookup<
      ffi.NativeFunction<
          spine_bounding_box_attachment Function(spine_skeleton_bounds,
              ffi.Float, ffi.Float)>>('spine_skeleton_bounds_contains_point_2');
  late final _spine_skeleton_bounds_contains_point_2 =
      _spine_skeleton_bounds_contains_point_2Ptr.asFunction<
          spine_bounding_box_attachment Function(
              spine_skeleton_bounds, double, double)>();

  spine_bounding_box_attachment spine_skeleton_bounds_intersects_segment_1(
    spine_skeleton_bounds self,
    double x1,
    double y1,
    double x2,
    double y2,
  ) {
    return _spine_skeleton_bounds_intersects_segment_1(
      self,
      x1,
      y1,
      x2,
      y2,
    );
  }

  late final _spine_skeleton_bounds_intersects_segment_1Ptr = _lookup<
      ffi.NativeFunction<
          spine_bounding_box_attachment Function(
              spine_skeleton_bounds,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_skeleton_bounds_intersects_segment_1');
  late final _spine_skeleton_bounds_intersects_segment_1 =
      _spine_skeleton_bounds_intersects_segment_1Ptr.asFunction<
          spine_bounding_box_attachment Function(
              spine_skeleton_bounds, double, double, double, double)>();

  bool spine_skeleton_bounds_intersects_segment_2(
    spine_skeleton_bounds self,
    spine_polygon polygon,
    double x1,
    double y1,
    double x2,
    double y2,
  ) {
    return _spine_skeleton_bounds_intersects_segment_2(
      self,
      polygon,
      x1,
      y1,
      x2,
      y2,
    );
  }

  late final _spine_skeleton_bounds_intersects_segment_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              spine_skeleton_bounds,
              spine_polygon,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_skeleton_bounds_intersects_segment_2');
  late final _spine_skeleton_bounds_intersects_segment_2 =
      _spine_skeleton_bounds_intersects_segment_2Ptr.asFunction<
          bool Function(spine_skeleton_bounds, spine_polygon, double, double,
              double, double)>();

  spine_polygon spine_skeleton_bounds_get_polygon(
    spine_skeleton_bounds self,
    spine_bounding_box_attachment attachment,
  ) {
    return _spine_skeleton_bounds_get_polygon(
      self,
      attachment,
    );
  }

  late final _spine_skeleton_bounds_get_polygonPtr = _lookup<
          ffi.NativeFunction<
              spine_polygon Function(
                  spine_skeleton_bounds, spine_bounding_box_attachment)>>(
      'spine_skeleton_bounds_get_polygon');
  late final _spine_skeleton_bounds_get_polygon =
      _spine_skeleton_bounds_get_polygonPtr.asFunction<
          spine_polygon Function(
              spine_skeleton_bounds, spine_bounding_box_attachment)>();

  spine_bounding_box_attachment spine_skeleton_bounds_get_bounding_box(
    spine_skeleton_bounds self,
    spine_polygon polygon,
  ) {
    return _spine_skeleton_bounds_get_bounding_box(
      self,
      polygon,
    );
  }

  late final _spine_skeleton_bounds_get_bounding_boxPtr = _lookup<
      ffi.NativeFunction<
          spine_bounding_box_attachment Function(spine_skeleton_bounds,
              spine_polygon)>>('spine_skeleton_bounds_get_bounding_box');
  late final _spine_skeleton_bounds_get_bounding_box =
      _spine_skeleton_bounds_get_bounding_boxPtr.asFunction<
          spine_bounding_box_attachment Function(
              spine_skeleton_bounds, spine_polygon)>();

  spine_array_polygon spine_skeleton_bounds_get_polygons(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_polygons(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_polygonsPtr = _lookup<
          ffi
          .NativeFunction<spine_array_polygon Function(spine_skeleton_bounds)>>(
      'spine_skeleton_bounds_get_polygons');
  late final _spine_skeleton_bounds_get_polygons =
      _spine_skeleton_bounds_get_polygonsPtr
          .asFunction<spine_array_polygon Function(spine_skeleton_bounds)>();

  spine_array_bounding_box_attachment spine_skeleton_bounds_get_bounding_boxes(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_bounding_boxes(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_bounding_boxesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_bounding_box_attachment Function(
                  spine_skeleton_bounds)>>(
      'spine_skeleton_bounds_get_bounding_boxes');
  late final _spine_skeleton_bounds_get_bounding_boxes =
      _spine_skeleton_bounds_get_bounding_boxesPtr.asFunction<
          spine_array_bounding_box_attachment Function(
              spine_skeleton_bounds)>();

  double spine_skeleton_bounds_get_min_x(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_min_x(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_min_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_bounds)>>(
          'spine_skeleton_bounds_get_min_x');
  late final _spine_skeleton_bounds_get_min_x =
      _spine_skeleton_bounds_get_min_xPtr
          .asFunction<double Function(spine_skeleton_bounds)>();

  double spine_skeleton_bounds_get_min_y(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_min_y(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_min_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_bounds)>>(
          'spine_skeleton_bounds_get_min_y');
  late final _spine_skeleton_bounds_get_min_y =
      _spine_skeleton_bounds_get_min_yPtr
          .asFunction<double Function(spine_skeleton_bounds)>();

  double spine_skeleton_bounds_get_max_x(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_max_x(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_max_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_bounds)>>(
          'spine_skeleton_bounds_get_max_x');
  late final _spine_skeleton_bounds_get_max_x =
      _spine_skeleton_bounds_get_max_xPtr
          .asFunction<double Function(spine_skeleton_bounds)>();

  double spine_skeleton_bounds_get_max_y(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_max_y(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_max_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_bounds)>>(
          'spine_skeleton_bounds_get_max_y');
  late final _spine_skeleton_bounds_get_max_y =
      _spine_skeleton_bounds_get_max_yPtr
          .asFunction<double Function(spine_skeleton_bounds)>();

  double spine_skeleton_bounds_get_width(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_width(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_bounds)>>(
          'spine_skeleton_bounds_get_width');
  late final _spine_skeleton_bounds_get_width =
      _spine_skeleton_bounds_get_widthPtr
          .asFunction<double Function(spine_skeleton_bounds)>();

  double spine_skeleton_bounds_get_height(
    spine_skeleton_bounds self,
  ) {
    return _spine_skeleton_bounds_get_height(
      self,
    );
  }

  late final _spine_skeleton_bounds_get_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_bounds)>>(
          'spine_skeleton_bounds_get_height');
  late final _spine_skeleton_bounds_get_height =
      _spine_skeleton_bounds_get_heightPtr
          .asFunction<double Function(spine_skeleton_bounds)>();

  spine_skeleton_clipping spine_skeleton_clipping_create() {
    return _spine_skeleton_clipping_create();
  }

  late final _spine_skeleton_clipping_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_clipping Function()>>(
          'spine_skeleton_clipping_create');
  late final _spine_skeleton_clipping_create =
      _spine_skeleton_clipping_createPtr
          .asFunction<spine_skeleton_clipping Function()>();

  void spine_skeleton_clipping_dispose(
    spine_skeleton_clipping self,
  ) {
    return _spine_skeleton_clipping_dispose(
      self,
    );
  }

  late final _spine_skeleton_clipping_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_clipping)>>(
          'spine_skeleton_clipping_dispose');
  late final _spine_skeleton_clipping_dispose =
      _spine_skeleton_clipping_disposePtr
          .asFunction<void Function(spine_skeleton_clipping)>();

  int spine_skeleton_clipping_clip_start(
    spine_skeleton_clipping self,
    spine_skeleton skeleton,
    spine_slot slot,
    spine_clipping_attachment clip,
  ) {
    return _spine_skeleton_clipping_clip_start(
      self,
      skeleton,
      slot,
      clip,
    );
  }

  late final _spine_skeleton_clipping_clip_startPtr = _lookup<
          ffi.NativeFunction<
              ffi.Size Function(spine_skeleton_clipping, spine_skeleton,
                  spine_slot, spine_clipping_attachment)>>(
      'spine_skeleton_clipping_clip_start');
  late final _spine_skeleton_clipping_clip_start =
      _spine_skeleton_clipping_clip_startPtr.asFunction<
          int Function(spine_skeleton_clipping, spine_skeleton, spine_slot,
              spine_clipping_attachment)>();

  void spine_skeleton_clipping_clip_end_1(
    spine_skeleton_clipping self,
    spine_slot slot,
  ) {
    return _spine_skeleton_clipping_clip_end_1(
      self,
      slot,
    );
  }

  late final _spine_skeleton_clipping_clip_end_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton_clipping,
              spine_slot)>>('spine_skeleton_clipping_clip_end_1');
  late final _spine_skeleton_clipping_clip_end_1 =
      _spine_skeleton_clipping_clip_end_1Ptr
          .asFunction<void Function(spine_skeleton_clipping, spine_slot)>();

  void spine_skeleton_clipping_clip_end_2(
    spine_skeleton_clipping self,
  ) {
    return _spine_skeleton_clipping_clip_end_2(
      self,
    );
  }

  late final _spine_skeleton_clipping_clip_end_2Ptr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_clipping)>>(
          'spine_skeleton_clipping_clip_end_2');
  late final _spine_skeleton_clipping_clip_end_2 =
      _spine_skeleton_clipping_clip_end_2Ptr
          .asFunction<void Function(spine_skeleton_clipping)>();

  bool spine_skeleton_clipping_clip_triangles_1(
    spine_skeleton_clipping self,
    ffi.Pointer<ffi.Float> vertices,
    ffi.Pointer<ffi.UnsignedShort> triangles,
    int trianglesLength,
  ) {
    return _spine_skeleton_clipping_clip_triangles_1(
      self,
      vertices,
      triangles,
      trianglesLength,
    );
  }

  late final _spine_skeleton_clipping_clip_triangles_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              spine_skeleton_clipping,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.UnsignedShort>,
              ffi.Size)>>('spine_skeleton_clipping_clip_triangles_1');
  late final _spine_skeleton_clipping_clip_triangles_1 =
      _spine_skeleton_clipping_clip_triangles_1Ptr.asFunction<
          bool Function(spine_skeleton_clipping, ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.UnsignedShort>, int)>();

  bool spine_skeleton_clipping_clip_triangles_2(
    spine_skeleton_clipping self,
    ffi.Pointer<ffi.Float> vertices,
    ffi.Pointer<ffi.UnsignedShort> triangles,
    int trianglesLength,
    ffi.Pointer<ffi.Float> uvs,
    int stride,
  ) {
    return _spine_skeleton_clipping_clip_triangles_2(
      self,
      vertices,
      triangles,
      trianglesLength,
      uvs,
      stride,
    );
  }

  late final _spine_skeleton_clipping_clip_triangles_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              spine_skeleton_clipping,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.UnsignedShort>,
              ffi.Size,
              ffi.Pointer<ffi.Float>,
              ffi.Size)>>('spine_skeleton_clipping_clip_triangles_2');
  late final _spine_skeleton_clipping_clip_triangles_2 =
      _spine_skeleton_clipping_clip_triangles_2Ptr.asFunction<
          bool Function(
              spine_skeleton_clipping,
              ffi.Pointer<ffi.Float>,
              ffi.Pointer<ffi.UnsignedShort>,
              int,
              ffi.Pointer<ffi.Float>,
              int)>();

  bool spine_skeleton_clipping_clip_triangles_3(
    spine_skeleton_clipping self,
    spine_array_float vertices,
    spine_array_unsigned_short triangles,
    spine_array_float uvs,
    int stride,
  ) {
    return _spine_skeleton_clipping_clip_triangles_3(
      self,
      vertices,
      triangles,
      uvs,
      stride,
    );
  }

  late final _spine_skeleton_clipping_clip_triangles_3Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Bool Function(
              spine_skeleton_clipping,
              spine_array_float,
              spine_array_unsigned_short,
              spine_array_float,
              ffi.Size)>>('spine_skeleton_clipping_clip_triangles_3');
  late final _spine_skeleton_clipping_clip_triangles_3 =
      _spine_skeleton_clipping_clip_triangles_3Ptr.asFunction<
          bool Function(spine_skeleton_clipping, spine_array_float,
              spine_array_unsigned_short, spine_array_float, int)>();

  bool spine_skeleton_clipping_is_clipping(
    spine_skeleton_clipping self,
  ) {
    return _spine_skeleton_clipping_is_clipping(
      self,
    );
  }

  late final _spine_skeleton_clipping_is_clippingPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_skeleton_clipping)>>(
          'spine_skeleton_clipping_is_clipping');
  late final _spine_skeleton_clipping_is_clipping =
      _spine_skeleton_clipping_is_clippingPtr
          .asFunction<bool Function(spine_skeleton_clipping)>();

  spine_array_float spine_skeleton_clipping_get_clipped_vertices(
    spine_skeleton_clipping self,
  ) {
    return _spine_skeleton_clipping_get_clipped_vertices(
      self,
    );
  }

  late final _spine_skeleton_clipping_get_clipped_verticesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_skeleton_clipping)>>(
      'spine_skeleton_clipping_get_clipped_vertices');
  late final _spine_skeleton_clipping_get_clipped_vertices =
      _spine_skeleton_clipping_get_clipped_verticesPtr
          .asFunction<spine_array_float Function(spine_skeleton_clipping)>();

  spine_array_unsigned_short spine_skeleton_clipping_get_clipped_triangles(
    spine_skeleton_clipping self,
  ) {
    return _spine_skeleton_clipping_get_clipped_triangles(
      self,
    );
  }

  late final _spine_skeleton_clipping_get_clipped_trianglesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_unsigned_short Function(spine_skeleton_clipping)>>(
      'spine_skeleton_clipping_get_clipped_triangles');
  late final _spine_skeleton_clipping_get_clipped_triangles =
      _spine_skeleton_clipping_get_clipped_trianglesPtr.asFunction<
          spine_array_unsigned_short Function(spine_skeleton_clipping)>();

  spine_array_float spine_skeleton_clipping_get_clipped_u_vs(
    spine_skeleton_clipping self,
  ) {
    return _spine_skeleton_clipping_get_clipped_u_vs(
      self,
    );
  }

  late final _spine_skeleton_clipping_get_clipped_u_vsPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_skeleton_clipping)>>(
      'spine_skeleton_clipping_get_clipped_u_vs');
  late final _spine_skeleton_clipping_get_clipped_u_vs =
      _spine_skeleton_clipping_get_clipped_u_vsPtr
          .asFunction<spine_array_float Function(spine_skeleton_clipping)>();

  spine_skeleton_data spine_skeleton_data_create() {
    return _spine_skeleton_data_create();
  }

  late final _spine_skeleton_data_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_data Function()>>(
          'spine_skeleton_data_create');
  late final _spine_skeleton_data_create = _spine_skeleton_data_createPtr
      .asFunction<spine_skeleton_data Function()>();

  void spine_skeleton_data_dispose(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_dispose(
      self,
    );
  }

  late final _spine_skeleton_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data)>>(
          'spine_skeleton_data_dispose');
  late final _spine_skeleton_data_dispose = _spine_skeleton_data_disposePtr
      .asFunction<void Function(spine_skeleton_data)>();

  spine_bone_data spine_skeleton_data_find_bone(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> boneName,
  ) {
    return _spine_skeleton_data_find_bone(
      self,
      boneName,
    );
  }

  late final _spine_skeleton_data_find_bonePtr = _lookup<
      ffi.NativeFunction<
          spine_bone_data Function(spine_skeleton_data,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_data_find_bone');
  late final _spine_skeleton_data_find_bone =
      _spine_skeleton_data_find_bonePtr.asFunction<
          spine_bone_data Function(
              spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  spine_slot_data spine_skeleton_data_find_slot(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> slotName,
  ) {
    return _spine_skeleton_data_find_slot(
      self,
      slotName,
    );
  }

  late final _spine_skeleton_data_find_slotPtr = _lookup<
      ffi.NativeFunction<
          spine_slot_data Function(spine_skeleton_data,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_data_find_slot');
  late final _spine_skeleton_data_find_slot =
      _spine_skeleton_data_find_slotPtr.asFunction<
          spine_slot_data Function(
              spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  spine_skin spine_skeleton_data_find_skin(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> skinName,
  ) {
    return _spine_skeleton_data_find_skin(
      self,
      skinName,
    );
  }

  late final _spine_skeleton_data_find_skinPtr = _lookup<
      ffi.NativeFunction<
          spine_skin Function(spine_skeleton_data,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_data_find_skin');
  late final _spine_skeleton_data_find_skin =
      _spine_skeleton_data_find_skinPtr.asFunction<
          spine_skin Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  spine_event_data spine_skeleton_data_find_event(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> eventDataName,
  ) {
    return _spine_skeleton_data_find_event(
      self,
      eventDataName,
    );
  }

  late final _spine_skeleton_data_find_eventPtr = _lookup<
      ffi.NativeFunction<
          spine_event_data Function(spine_skeleton_data,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_data_find_event');
  late final _spine_skeleton_data_find_event =
      _spine_skeleton_data_find_eventPtr.asFunction<
          spine_event_data Function(
              spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  spine_animation spine_skeleton_data_find_animation(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> animationName,
  ) {
    return _spine_skeleton_data_find_animation(
      self,
      animationName,
    );
  }

  late final _spine_skeleton_data_find_animationPtr = _lookup<
      ffi.NativeFunction<
          spine_animation Function(spine_skeleton_data,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_data_find_animation');
  late final _spine_skeleton_data_find_animation =
      _spine_skeleton_data_find_animationPtr.asFunction<
          spine_animation Function(
              spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> spine_skeleton_data_get_name(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_name(
      self,
    );
  }

  late final _spine_skeleton_data_get_namePtr = _lookup<
          ffi
          .NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>>(
      'spine_skeleton_data_get_name');
  late final _spine_skeleton_data_get_name = _spine_skeleton_data_get_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_name(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_skeleton_data_set_name(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton_data,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_data_set_name');
  late final _spine_skeleton_data_set_name = _spine_skeleton_data_set_namePtr
      .asFunction<void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  spine_array_bone_data spine_skeleton_data_get_bones(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_bones(
      self,
    );
  }

  late final _spine_skeleton_data_get_bonesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_bone_data Function(spine_skeleton_data)>>(
      'spine_skeleton_data_get_bones');
  late final _spine_skeleton_data_get_bones = _spine_skeleton_data_get_bonesPtr
      .asFunction<spine_array_bone_data Function(spine_skeleton_data)>();

  spine_array_slot_data spine_skeleton_data_get_slots(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_slots(
      self,
    );
  }

  late final _spine_skeleton_data_get_slotsPtr = _lookup<
          ffi
          .NativeFunction<spine_array_slot_data Function(spine_skeleton_data)>>(
      'spine_skeleton_data_get_slots');
  late final _spine_skeleton_data_get_slots = _spine_skeleton_data_get_slotsPtr
      .asFunction<spine_array_slot_data Function(spine_skeleton_data)>();

  spine_array_skin spine_skeleton_data_get_skins(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_skins(
      self,
    );
  }

  late final _spine_skeleton_data_get_skinsPtr = _lookup<
          ffi.NativeFunction<spine_array_skin Function(spine_skeleton_data)>>(
      'spine_skeleton_data_get_skins');
  late final _spine_skeleton_data_get_skins = _spine_skeleton_data_get_skinsPtr
      .asFunction<spine_array_skin Function(spine_skeleton_data)>();

  spine_skin spine_skeleton_data_get_default_skin(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_default_skin(
      self,
    );
  }

  late final _spine_skeleton_data_get_default_skinPtr =
      _lookup<ffi.NativeFunction<spine_skin Function(spine_skeleton_data)>>(
          'spine_skeleton_data_get_default_skin');
  late final _spine_skeleton_data_get_default_skin =
      _spine_skeleton_data_get_default_skinPtr
          .asFunction<spine_skin Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_default_skin(
    spine_skeleton_data self,
    spine_skin inValue,
  ) {
    return _spine_skeleton_data_set_default_skin(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_default_skinPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_skeleton_data, spine_skin)>>(
      'spine_skeleton_data_set_default_skin');
  late final _spine_skeleton_data_set_default_skin =
      _spine_skeleton_data_set_default_skinPtr
          .asFunction<void Function(spine_skeleton_data, spine_skin)>();

  spine_array_event_data spine_skeleton_data_get_events(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_events(
      self,
    );
  }

  late final _spine_skeleton_data_get_eventsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_event_data Function(
              spine_skeleton_data)>>('spine_skeleton_data_get_events');
  late final _spine_skeleton_data_get_events =
      _spine_skeleton_data_get_eventsPtr
          .asFunction<spine_array_event_data Function(spine_skeleton_data)>();

  spine_array_animation spine_skeleton_data_get_animations(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_animations(
      self,
    );
  }

  late final _spine_skeleton_data_get_animationsPtr = _lookup<
          ffi
          .NativeFunction<spine_array_animation Function(spine_skeleton_data)>>(
      'spine_skeleton_data_get_animations');
  late final _spine_skeleton_data_get_animations =
      _spine_skeleton_data_get_animationsPtr
          .asFunction<spine_array_animation Function(spine_skeleton_data)>();

  spine_array_constraint_data spine_skeleton_data_get_constraints(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_constraints(
      self,
    );
  }

  late final _spine_skeleton_data_get_constraintsPtr = _lookup<
      ffi.NativeFunction<
          spine_array_constraint_data Function(
              spine_skeleton_data)>>('spine_skeleton_data_get_constraints');
  late final _spine_skeleton_data_get_constraints =
      _spine_skeleton_data_get_constraintsPtr.asFunction<
          spine_array_constraint_data Function(spine_skeleton_data)>();

  double spine_skeleton_data_get_x(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_x(
      self,
    );
  }

  late final _spine_skeleton_data_get_xPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>(
          'spine_skeleton_data_get_x');
  late final _spine_skeleton_data_get_x = _spine_skeleton_data_get_xPtr
      .asFunction<double Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_x(
    spine_skeleton_data self,
    double inValue,
  ) {
    return _spine_skeleton_data_set_x(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_xPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>(
      'spine_skeleton_data_set_x');
  late final _spine_skeleton_data_set_x = _spine_skeleton_data_set_xPtr
      .asFunction<void Function(spine_skeleton_data, double)>();

  double spine_skeleton_data_get_y(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_y(
      self,
    );
  }

  late final _spine_skeleton_data_get_yPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>(
          'spine_skeleton_data_get_y');
  late final _spine_skeleton_data_get_y = _spine_skeleton_data_get_yPtr
      .asFunction<double Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_y(
    spine_skeleton_data self,
    double inValue,
  ) {
    return _spine_skeleton_data_set_y(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_yPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>(
      'spine_skeleton_data_set_y');
  late final _spine_skeleton_data_set_y = _spine_skeleton_data_set_yPtr
      .asFunction<void Function(spine_skeleton_data, double)>();

  double spine_skeleton_data_get_width(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_width(
      self,
    );
  }

  late final _spine_skeleton_data_get_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>(
          'spine_skeleton_data_get_width');
  late final _spine_skeleton_data_get_width = _spine_skeleton_data_get_widthPtr
      .asFunction<double Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_width(
    spine_skeleton_data self,
    double inValue,
  ) {
    return _spine_skeleton_data_set_width(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_widthPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>(
      'spine_skeleton_data_set_width');
  late final _spine_skeleton_data_set_width = _spine_skeleton_data_set_widthPtr
      .asFunction<void Function(spine_skeleton_data, double)>();

  double spine_skeleton_data_get_height(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_height(
      self,
    );
  }

  late final _spine_skeleton_data_get_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>(
          'spine_skeleton_data_get_height');
  late final _spine_skeleton_data_get_height =
      _spine_skeleton_data_get_heightPtr
          .asFunction<double Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_height(
    spine_skeleton_data self,
    double inValue,
  ) {
    return _spine_skeleton_data_set_height(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_heightPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>(
      'spine_skeleton_data_set_height');
  late final _spine_skeleton_data_set_height =
      _spine_skeleton_data_set_heightPtr
          .asFunction<void Function(spine_skeleton_data, double)>();

  double spine_skeleton_data_get_reference_scale(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_reference_scale(
      self,
    );
  }

  late final _spine_skeleton_data_get_reference_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>(
          'spine_skeleton_data_get_reference_scale');
  late final _spine_skeleton_data_get_reference_scale =
      _spine_skeleton_data_get_reference_scalePtr
          .asFunction<double Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_reference_scale(
    spine_skeleton_data self,
    double inValue,
  ) {
    return _spine_skeleton_data_set_reference_scale(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_reference_scalePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>(
      'spine_skeleton_data_set_reference_scale');
  late final _spine_skeleton_data_set_reference_scale =
      _spine_skeleton_data_set_reference_scalePtr
          .asFunction<void Function(spine_skeleton_data, double)>();

  ffi.Pointer<ffi.Char> spine_skeleton_data_get_version(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_version(
      self,
    );
  }

  late final _spine_skeleton_data_get_versionPtr = _lookup<
          ffi
          .NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>>(
      'spine_skeleton_data_get_version');
  late final _spine_skeleton_data_get_version =
      _spine_skeleton_data_get_versionPtr
          .asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_version(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_skeleton_data_set_version(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_versionPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton_data,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_data_set_version');
  late final _spine_skeleton_data_set_version =
      _spine_skeleton_data_set_versionPtr.asFunction<
          void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> spine_skeleton_data_get_hash(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_hash(
      self,
    );
  }

  late final _spine_skeleton_data_get_hashPtr = _lookup<
          ffi
          .NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>>(
      'spine_skeleton_data_get_hash');
  late final _spine_skeleton_data_get_hash = _spine_skeleton_data_get_hashPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_hash(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_skeleton_data_set_hash(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_hashPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton_data,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_data_set_hash');
  late final _spine_skeleton_data_set_hash = _spine_skeleton_data_set_hashPtr
      .asFunction<void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> spine_skeleton_data_get_images_path(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_images_path(
      self,
    );
  }

  late final _spine_skeleton_data_get_images_pathPtr = _lookup<
          ffi
          .NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>>(
      'spine_skeleton_data_get_images_path');
  late final _spine_skeleton_data_get_images_path =
      _spine_skeleton_data_get_images_pathPtr
          .asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_images_path(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_skeleton_data_set_images_path(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_images_pathPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton_data,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_data_set_images_path');
  late final _spine_skeleton_data_set_images_path =
      _spine_skeleton_data_set_images_pathPtr.asFunction<
          void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> spine_skeleton_data_get_audio_path(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_audio_path(
      self,
    );
  }

  late final _spine_skeleton_data_get_audio_pathPtr = _lookup<
          ffi
          .NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>>(
      'spine_skeleton_data_get_audio_path');
  late final _spine_skeleton_data_get_audio_path =
      _spine_skeleton_data_get_audio_pathPtr
          .asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_audio_path(
    spine_skeleton_data self,
    ffi.Pointer<ffi.Char> inValue,
  ) {
    return _spine_skeleton_data_set_audio_path(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_audio_pathPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skeleton_data,
              ffi.Pointer<ffi.Char>)>>('spine_skeleton_data_set_audio_path');
  late final _spine_skeleton_data_set_audio_path =
      _spine_skeleton_data_set_audio_pathPtr.asFunction<
          void Function(spine_skeleton_data, ffi.Pointer<ffi.Char>)>();

  double spine_skeleton_data_get_fps(
    spine_skeleton_data self,
  ) {
    return _spine_skeleton_data_get_fps(
      self,
    );
  }

  late final _spine_skeleton_data_get_fpsPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>(
          'spine_skeleton_data_get_fps');
  late final _spine_skeleton_data_get_fps = _spine_skeleton_data_get_fpsPtr
      .asFunction<double Function(spine_skeleton_data)>();

  void spine_skeleton_data_set_fps(
    spine_skeleton_data self,
    double inValue,
  ) {
    return _spine_skeleton_data_set_fps(
      self,
      inValue,
    );
  }

  late final _spine_skeleton_data_set_fpsPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>(
      'spine_skeleton_data_set_fps');
  late final _spine_skeleton_data_set_fps = _spine_skeleton_data_set_fpsPtr
      .asFunction<void Function(spine_skeleton_data, double)>();

  spine_skeleton_json spine_skeleton_json_create(
    spine_atlas atlas,
  ) {
    return _spine_skeleton_json_create(
      atlas,
    );
  }

  late final _spine_skeleton_json_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_json Function(spine_atlas)>>(
          'spine_skeleton_json_create');
  late final _spine_skeleton_json_create = _spine_skeleton_json_createPtr
      .asFunction<spine_skeleton_json Function(spine_atlas)>();

  spine_skeleton_json spine_skeleton_json_create2(
    spine_attachment_loader attachmentLoader,
    bool ownsLoader,
  ) {
    return _spine_skeleton_json_create2(
      attachmentLoader,
      ownsLoader,
    );
  }

  late final _spine_skeleton_json_create2Ptr = _lookup<
      ffi.NativeFunction<
          spine_skeleton_json Function(spine_attachment_loader,
              ffi.Bool)>>('spine_skeleton_json_create2');
  late final _spine_skeleton_json_create2 =
      _spine_skeleton_json_create2Ptr.asFunction<
          spine_skeleton_json Function(spine_attachment_loader, bool)>();

  void spine_skeleton_json_dispose(
    spine_skeleton_json self,
  ) {
    return _spine_skeleton_json_dispose(
      self,
    );
  }

  late final _spine_skeleton_json_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_json)>>(
          'spine_skeleton_json_dispose');
  late final _spine_skeleton_json_dispose = _spine_skeleton_json_disposePtr
      .asFunction<void Function(spine_skeleton_json)>();

  spine_skeleton_data spine_skeleton_json_read_skeleton_data_file(
    spine_skeleton_json self,
    ffi.Pointer<ffi.Char> path,
  ) {
    return _spine_skeleton_json_read_skeleton_data_file(
      self,
      path,
    );
  }

  late final _spine_skeleton_json_read_skeleton_data_filePtr = _lookup<
          ffi.NativeFunction<
              spine_skeleton_data Function(
                  spine_skeleton_json, ffi.Pointer<ffi.Char>)>>(
      'spine_skeleton_json_read_skeleton_data_file');
  late final _spine_skeleton_json_read_skeleton_data_file =
      _spine_skeleton_json_read_skeleton_data_filePtr.asFunction<
          spine_skeleton_data Function(
              spine_skeleton_json, ffi.Pointer<ffi.Char>)>();

  spine_skeleton_data spine_skeleton_json_read_skeleton_data(
    spine_skeleton_json self,
    ffi.Pointer<ffi.Char> json,
  ) {
    return _spine_skeleton_json_read_skeleton_data(
      self,
      json,
    );
  }

  late final _spine_skeleton_json_read_skeleton_dataPtr = _lookup<
          ffi.NativeFunction<
              spine_skeleton_data Function(
                  spine_skeleton_json, ffi.Pointer<ffi.Char>)>>(
      'spine_skeleton_json_read_skeleton_data');
  late final _spine_skeleton_json_read_skeleton_data =
      _spine_skeleton_json_read_skeleton_dataPtr.asFunction<
          spine_skeleton_data Function(
              spine_skeleton_json, ffi.Pointer<ffi.Char>)>();

  void spine_skeleton_json_set_scale(
    spine_skeleton_json self,
    double scale,
  ) {
    return _spine_skeleton_json_set_scale(
      self,
      scale,
    );
  }

  late final _spine_skeleton_json_set_scalePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_skeleton_json, ffi.Float)>>(
      'spine_skeleton_json_set_scale');
  late final _spine_skeleton_json_set_scale = _spine_skeleton_json_set_scalePtr
      .asFunction<void Function(spine_skeleton_json, double)>();

  ffi.Pointer<ffi.Char> spine_skeleton_json_get_error(
    spine_skeleton_json self,
  ) {
    return _spine_skeleton_json_get_error(
      self,
    );
  }

  late final _spine_skeleton_json_get_errorPtr = _lookup<
          ffi
          .NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_json)>>(
      'spine_skeleton_json_get_error');
  late final _spine_skeleton_json_get_error = _spine_skeleton_json_get_errorPtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_skeleton_json)>();

  spine_skeleton_renderer spine_skeleton_renderer_create() {
    return _spine_skeleton_renderer_create();
  }

  late final _spine_skeleton_renderer_createPtr =
      _lookup<ffi.NativeFunction<spine_skeleton_renderer Function()>>(
          'spine_skeleton_renderer_create');
  late final _spine_skeleton_renderer_create =
      _spine_skeleton_renderer_createPtr
          .asFunction<spine_skeleton_renderer Function()>();

  void spine_skeleton_renderer_dispose(
    spine_skeleton_renderer self,
  ) {
    return _spine_skeleton_renderer_dispose(
      self,
    );
  }

  late final _spine_skeleton_renderer_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_renderer)>>(
          'spine_skeleton_renderer_dispose');
  late final _spine_skeleton_renderer_dispose =
      _spine_skeleton_renderer_disposePtr
          .asFunction<void Function(spine_skeleton_renderer)>();

  spine_render_command spine_skeleton_renderer_render(
    spine_skeleton_renderer self,
    spine_skeleton skeleton,
  ) {
    return _spine_skeleton_renderer_render(
      self,
      skeleton,
    );
  }

  late final _spine_skeleton_renderer_renderPtr = _lookup<
      ffi.NativeFunction<
          spine_render_command Function(spine_skeleton_renderer,
              spine_skeleton)>>('spine_skeleton_renderer_render');
  late final _spine_skeleton_renderer_render =
      _spine_skeleton_renderer_renderPtr.asFunction<
          spine_render_command Function(
              spine_skeleton_renderer, spine_skeleton)>();

  spine_skin spine_skin_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_skin_create(
      name,
    );
  }

  late final _spine_skin_createPtr =
      _lookup<ffi.NativeFunction<spine_skin Function(ffi.Pointer<ffi.Char>)>>(
          'spine_skin_create');
  late final _spine_skin_create = _spine_skin_createPtr
      .asFunction<spine_skin Function(ffi.Pointer<ffi.Char>)>();

  void spine_skin_dispose(
    spine_skin self,
  ) {
    return _spine_skin_dispose(
      self,
    );
  }

  late final _spine_skin_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin)>>(
          'spine_skin_dispose');
  late final _spine_skin_dispose =
      _spine_skin_disposePtr.asFunction<void Function(spine_skin)>();

  void spine_skin_set_attachment(
    spine_skin self,
    int slotIndex,
    ffi.Pointer<ffi.Char> name,
    spine_attachment attachment,
  ) {
    return _spine_skin_set_attachment(
      self,
      slotIndex,
      name,
      attachment,
    );
  }

  late final _spine_skin_set_attachmentPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skin, ffi.Size, ffi.Pointer<ffi.Char>,
              spine_attachment)>>('spine_skin_set_attachment');
  late final _spine_skin_set_attachment =
      _spine_skin_set_attachmentPtr.asFunction<
          void Function(
              spine_skin, int, ffi.Pointer<ffi.Char>, spine_attachment)>();

  spine_attachment spine_skin_get_attachment(
    spine_skin self,
    int slotIndex,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_skin_get_attachment(
      self,
      slotIndex,
      name,
    );
  }

  late final _spine_skin_get_attachmentPtr = _lookup<
      ffi.NativeFunction<
          spine_attachment Function(spine_skin, ffi.Size,
              ffi.Pointer<ffi.Char>)>>('spine_skin_get_attachment');
  late final _spine_skin_get_attachment =
      _spine_skin_get_attachmentPtr.asFunction<
          spine_attachment Function(spine_skin, int, ffi.Pointer<ffi.Char>)>();

  void spine_skin_remove_attachment(
    spine_skin self,
    int slotIndex,
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_skin_remove_attachment(
      self,
      slotIndex,
      name,
    );
  }

  late final _spine_skin_remove_attachmentPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skin, ffi.Size,
              ffi.Pointer<ffi.Char>)>>('spine_skin_remove_attachment');
  late final _spine_skin_remove_attachment = _spine_skin_remove_attachmentPtr
      .asFunction<void Function(spine_skin, int, ffi.Pointer<ffi.Char>)>();

  void spine_skin_find_attachments_for_slot(
    spine_skin self,
    int slotIndex,
    spine_array_attachment attachments,
  ) {
    return _spine_skin_find_attachments_for_slot(
      self,
      slotIndex,
      attachments,
    );
  }

  late final _spine_skin_find_attachments_for_slotPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_skin, ffi.Size,
              spine_array_attachment)>>('spine_skin_find_attachments_for_slot');
  late final _spine_skin_find_attachments_for_slot =
      _spine_skin_find_attachments_for_slotPtr
          .asFunction<void Function(spine_skin, int, spine_array_attachment)>();

  ffi.Pointer<ffi.Char> spine_skin_get_name(
    spine_skin self,
  ) {
    return _spine_skin_get_name(
      self,
    );
  }

  late final _spine_skin_get_namePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_skin)>>(
          'spine_skin_get_name');
  late final _spine_skin_get_name = _spine_skin_get_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_skin)>();

  void spine_skin_add_skin(
    spine_skin self,
    spine_skin other,
  ) {
    return _spine_skin_add_skin(
      self,
      other,
    );
  }

  late final _spine_skin_add_skinPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin, spine_skin)>>(
          'spine_skin_add_skin');
  late final _spine_skin_add_skin = _spine_skin_add_skinPtr
      .asFunction<void Function(spine_skin, spine_skin)>();

  void spine_skin_copy_skin(
    spine_skin self,
    spine_skin other,
  ) {
    return _spine_skin_copy_skin(
      self,
      other,
    );
  }

  late final _spine_skin_copy_skinPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin, spine_skin)>>(
          'spine_skin_copy_skin');
  late final _spine_skin_copy_skin = _spine_skin_copy_skinPtr
      .asFunction<void Function(spine_skin, spine_skin)>();

  spine_array_bone_data spine_skin_get_bones(
    spine_skin self,
  ) {
    return _spine_skin_get_bones(
      self,
    );
  }

  late final _spine_skin_get_bonesPtr =
      _lookup<ffi.NativeFunction<spine_array_bone_data Function(spine_skin)>>(
          'spine_skin_get_bones');
  late final _spine_skin_get_bones = _spine_skin_get_bonesPtr
      .asFunction<spine_array_bone_data Function(spine_skin)>();

  spine_array_constraint_data spine_skin_get_constraints(
    spine_skin self,
  ) {
    return _spine_skin_get_constraints(
      self,
    );
  }

  late final _spine_skin_get_constraintsPtr = _lookup<
          ffi.NativeFunction<spine_array_constraint_data Function(spine_skin)>>(
      'spine_skin_get_constraints');
  late final _spine_skin_get_constraints = _spine_skin_get_constraintsPtr
      .asFunction<spine_array_constraint_data Function(spine_skin)>();

  spine_color spine_skin_get_color(
    spine_skin self,
  ) {
    return _spine_skin_get_color(
      self,
    );
  }

  late final _spine_skin_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_skin)>>(
          'spine_skin_get_color');
  late final _spine_skin_get_color =
      _spine_skin_get_colorPtr.asFunction<spine_color Function(spine_skin)>();

  spine_slider spine_slider_create(
    spine_slider_data data,
    spine_skeleton skeleton,
  ) {
    return _spine_slider_create(
      data,
      skeleton,
    );
  }

  late final _spine_slider_createPtr = _lookup<
      ffi.NativeFunction<
          spine_slider Function(
              spine_slider_data, spine_skeleton)>>('spine_slider_create');
  late final _spine_slider_create = _spine_slider_createPtr
      .asFunction<spine_slider Function(spine_slider_data, spine_skeleton)>();

  void spine_slider_dispose(
    spine_slider self,
  ) {
    return _spine_slider_dispose(
      self,
    );
  }

  late final _spine_slider_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider)>>(
          'spine_slider_dispose');
  late final _spine_slider_dispose =
      _spine_slider_disposePtr.asFunction<void Function(spine_slider)>();

  spine_rtti spine_slider_get_rtti(
    spine_slider self,
  ) {
    return _spine_slider_get_rtti(
      self,
    );
  }

  late final _spine_slider_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_slider)>>(
          'spine_slider_get_rtti');
  late final _spine_slider_get_rtti =
      _spine_slider_get_rttiPtr.asFunction<spine_rtti Function(spine_slider)>();

  spine_slider spine_slider_copy(
    spine_slider self,
    spine_skeleton skeleton,
  ) {
    return _spine_slider_copy(
      self,
      skeleton,
    );
  }

  late final _spine_slider_copyPtr = _lookup<
          ffi
          .NativeFunction<spine_slider Function(spine_slider, spine_skeleton)>>(
      'spine_slider_copy');
  late final _spine_slider_copy = _spine_slider_copyPtr
      .asFunction<spine_slider Function(spine_slider, spine_skeleton)>();

  void spine_slider_update(
    spine_slider self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_slider_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_slider_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_slider, spine_skeleton, ffi.Int32)>>('spine_slider_update');
  late final _spine_slider_update = _spine_slider_updatePtr
      .asFunction<void Function(spine_slider, spine_skeleton, int)>();

  void spine_slider_sort(
    spine_slider self,
    spine_skeleton skeleton,
  ) {
    return _spine_slider_sort(
      self,
      skeleton,
    );
  }

  late final _spine_slider_sortPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_slider, spine_skeleton)>>(
      'spine_slider_sort');
  late final _spine_slider_sort = _spine_slider_sortPtr
      .asFunction<void Function(spine_slider, spine_skeleton)>();

  bool spine_slider_is_source_active(
    spine_slider self,
  ) {
    return _spine_slider_is_source_active(
      self,
    );
  }

  late final _spine_slider_is_source_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider)>>(
          'spine_slider_is_source_active');
  late final _spine_slider_is_source_active = _spine_slider_is_source_activePtr
      .asFunction<bool Function(spine_slider)>();

  spine_bone spine_slider_get_bone(
    spine_slider self,
  ) {
    return _spine_slider_get_bone(
      self,
    );
  }

  late final _spine_slider_get_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_slider)>>(
          'spine_slider_get_bone');
  late final _spine_slider_get_bone =
      _spine_slider_get_bonePtr.asFunction<spine_bone Function(spine_slider)>();

  void spine_slider_set_bone(
    spine_slider self,
    spine_bone bone,
  ) {
    return _spine_slider_set_bone(
      self,
      bone,
    );
  }

  late final _spine_slider_set_bonePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider, spine_bone)>>(
          'spine_slider_set_bone');
  late final _spine_slider_set_bone = _spine_slider_set_bonePtr
      .asFunction<void Function(spine_slider, spine_bone)>();

  spine_slider_data spine_slider_get_data(
    spine_slider self,
  ) {
    return _spine_slider_get_data(
      self,
    );
  }

  late final _spine_slider_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_slider_data Function(spine_slider)>>(
          'spine_slider_get_data');
  late final _spine_slider_get_data = _spine_slider_get_dataPtr
      .asFunction<spine_slider_data Function(spine_slider)>();

  spine_slider_pose spine_slider_get_pose(
    spine_slider self,
  ) {
    return _spine_slider_get_pose(
      self,
    );
  }

  late final _spine_slider_get_posePtr =
      _lookup<ffi.NativeFunction<spine_slider_pose Function(spine_slider)>>(
          'spine_slider_get_pose');
  late final _spine_slider_get_pose = _spine_slider_get_posePtr
      .asFunction<spine_slider_pose Function(spine_slider)>();

  spine_slider_pose spine_slider_get_applied_pose(
    spine_slider self,
  ) {
    return _spine_slider_get_applied_pose(
      self,
    );
  }

  late final _spine_slider_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_slider_pose Function(spine_slider)>>(
          'spine_slider_get_applied_pose');
  late final _spine_slider_get_applied_pose = _spine_slider_get_applied_posePtr
      .asFunction<spine_slider_pose Function(spine_slider)>();

  void spine_slider_reset_constrained(
    spine_slider self,
  ) {
    return _spine_slider_reset_constrained(
      self,
    );
  }

  late final _spine_slider_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider)>>(
          'spine_slider_reset_constrained');
  late final _spine_slider_reset_constrained =
      _spine_slider_reset_constrainedPtr
          .asFunction<void Function(spine_slider)>();

  void spine_slider_constrained(
    spine_slider self,
  ) {
    return _spine_slider_constrained(
      self,
    );
  }

  late final _spine_slider_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider)>>(
          'spine_slider_constrained');
  late final _spine_slider_constrained =
      _spine_slider_constrainedPtr.asFunction<void Function(spine_slider)>();

  bool spine_slider_is_pose_equal_to_applied(
    spine_slider self,
  ) {
    return _spine_slider_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_slider_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider)>>(
          'spine_slider_is_pose_equal_to_applied');
  late final _spine_slider_is_pose_equal_to_applied =
      _spine_slider_is_pose_equal_to_appliedPtr
          .asFunction<bool Function(spine_slider)>();

  bool spine_slider_is_active(
    spine_slider self,
  ) {
    return _spine_slider_is_active(
      self,
    );
  }

  late final _spine_slider_is_activePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider)>>(
          'spine_slider_is_active');
  late final _spine_slider_is_active =
      _spine_slider_is_activePtr.asFunction<bool Function(spine_slider)>();

  void spine_slider_set_active(
    spine_slider self,
    bool active,
  ) {
    return _spine_slider_set_active(
      self,
      active,
    );
  }

  late final _spine_slider_set_activePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider, ffi.Bool)>>(
          'spine_slider_set_active');
  late final _spine_slider_set_active = _spine_slider_set_activePtr
      .asFunction<void Function(spine_slider, bool)>();

  spine_rtti spine_slider_rtti() {
    return _spine_slider_rtti();
  }

  late final _spine_slider_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_slider_rtti');
  late final _spine_slider_rtti =
      _spine_slider_rttiPtr.asFunction<spine_rtti Function()>();

  spine_slider_data spine_slider_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_slider_data_create(
      name,
    );
  }

  late final _spine_slider_data_createPtr = _lookup<
          ffi
          .NativeFunction<spine_slider_data Function(ffi.Pointer<ffi.Char>)>>(
      'spine_slider_data_create');
  late final _spine_slider_data_create = _spine_slider_data_createPtr
      .asFunction<spine_slider_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_slider_data_dispose(
    spine_slider_data self,
  ) {
    return _spine_slider_data_dispose(
      self,
    );
  }

  late final _spine_slider_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_data)>>(
          'spine_slider_data_dispose');
  late final _spine_slider_data_dispose = _spine_slider_data_disposePtr
      .asFunction<void Function(spine_slider_data)>();

  spine_rtti spine_slider_data_get_rtti(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_rtti(
      self,
    );
  }

  late final _spine_slider_data_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_slider_data)>>(
          'spine_slider_data_get_rtti');
  late final _spine_slider_data_get_rtti = _spine_slider_data_get_rttiPtr
      .asFunction<spine_rtti Function(spine_slider_data)>();

  spine_constraint spine_slider_data_create_method(
    spine_slider_data self,
    spine_skeleton skeleton,
  ) {
    return _spine_slider_data_create_method(
      self,
      skeleton,
    );
  }

  late final _spine_slider_data_create_methodPtr = _lookup<
      ffi.NativeFunction<
          spine_constraint Function(spine_slider_data,
              spine_skeleton)>>('spine_slider_data_create_method');
  late final _spine_slider_data_create_method =
      _spine_slider_data_create_methodPtr.asFunction<
          spine_constraint Function(spine_slider_data, spine_skeleton)>();

  spine_animation spine_slider_data_get_animation(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_animation(
      self,
    );
  }

  late final _spine_slider_data_get_animationPtr =
      _lookup<ffi.NativeFunction<spine_animation Function(spine_slider_data)>>(
          'spine_slider_data_get_animation');
  late final _spine_slider_data_get_animation =
      _spine_slider_data_get_animationPtr
          .asFunction<spine_animation Function(spine_slider_data)>();

  void spine_slider_data_set_animation(
    spine_slider_data self,
    spine_animation animation,
  ) {
    return _spine_slider_data_set_animation(
      self,
      animation,
    );
  }

  late final _spine_slider_data_set_animationPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slider_data,
              spine_animation)>>('spine_slider_data_set_animation');
  late final _spine_slider_data_set_animation =
      _spine_slider_data_set_animationPtr
          .asFunction<void Function(spine_slider_data, spine_animation)>();

  bool spine_slider_data_get_additive(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_additive(
      self,
    );
  }

  late final _spine_slider_data_get_additivePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider_data)>>(
          'spine_slider_data_get_additive');
  late final _spine_slider_data_get_additive =
      _spine_slider_data_get_additivePtr
          .asFunction<bool Function(spine_slider_data)>();

  void spine_slider_data_set_additive(
    spine_slider_data self,
    bool additive,
  ) {
    return _spine_slider_data_set_additive(
      self,
      additive,
    );
  }

  late final _spine_slider_data_set_additivePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_slider_data, ffi.Bool)>>(
      'spine_slider_data_set_additive');
  late final _spine_slider_data_set_additive =
      _spine_slider_data_set_additivePtr
          .asFunction<void Function(spine_slider_data, bool)>();

  bool spine_slider_data_get_loop(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_loop(
      self,
    );
  }

  late final _spine_slider_data_get_loopPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider_data)>>(
          'spine_slider_data_get_loop');
  late final _spine_slider_data_get_loop = _spine_slider_data_get_loopPtr
      .asFunction<bool Function(spine_slider_data)>();

  void spine_slider_data_set_loop(
    spine_slider_data self,
    bool loop,
  ) {
    return _spine_slider_data_set_loop(
      self,
      loop,
    );
  }

  late final _spine_slider_data_set_loopPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_slider_data, ffi.Bool)>>(
      'spine_slider_data_set_loop');
  late final _spine_slider_data_set_loop = _spine_slider_data_set_loopPtr
      .asFunction<void Function(spine_slider_data, bool)>();

  spine_bone_data spine_slider_data_get_bone(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_bone(
      self,
    );
  }

  late final _spine_slider_data_get_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_slider_data)>>(
          'spine_slider_data_get_bone');
  late final _spine_slider_data_get_bone = _spine_slider_data_get_bonePtr
      .asFunction<spine_bone_data Function(spine_slider_data)>();

  void spine_slider_data_set_bone(
    spine_slider_data self,
    spine_bone_data bone,
  ) {
    return _spine_slider_data_set_bone(
      self,
      bone,
    );
  }

  late final _spine_slider_data_set_bonePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slider_data,
              spine_bone_data)>>('spine_slider_data_set_bone');
  late final _spine_slider_data_set_bone = _spine_slider_data_set_bonePtr
      .asFunction<void Function(spine_slider_data, spine_bone_data)>();

  spine_from_property spine_slider_data_get_property(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_property(
      self,
    );
  }

  late final _spine_slider_data_get_propertyPtr = _lookup<
          ffi.NativeFunction<spine_from_property Function(spine_slider_data)>>(
      'spine_slider_data_get_property');
  late final _spine_slider_data_get_property =
      _spine_slider_data_get_propertyPtr
          .asFunction<spine_from_property Function(spine_slider_data)>();

  void spine_slider_data_set_property(
    spine_slider_data self,
    spine_from_property property,
  ) {
    return _spine_slider_data_set_property(
      self,
      property,
    );
  }

  late final _spine_slider_data_set_propertyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slider_data,
              spine_from_property)>>('spine_slider_data_set_property');
  late final _spine_slider_data_set_property =
      _spine_slider_data_set_propertyPtr
          .asFunction<void Function(spine_slider_data, spine_from_property)>();

  double spine_slider_data_get_scale(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_scale(
      self,
    );
  }

  late final _spine_slider_data_get_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_data)>>(
          'spine_slider_data_get_scale');
  late final _spine_slider_data_get_scale = _spine_slider_data_get_scalePtr
      .asFunction<double Function(spine_slider_data)>();

  void spine_slider_data_set_scale(
    spine_slider_data self,
    double scale,
  ) {
    return _spine_slider_data_set_scale(
      self,
      scale,
    );
  }

  late final _spine_slider_data_set_scalePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_slider_data, ffi.Float)>>(
      'spine_slider_data_set_scale');
  late final _spine_slider_data_set_scale = _spine_slider_data_set_scalePtr
      .asFunction<void Function(spine_slider_data, double)>();

  double spine_slider_data_get_offset(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_offset(
      self,
    );
  }

  late final _spine_slider_data_get_offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_data)>>(
          'spine_slider_data_get_offset');
  late final _spine_slider_data_get_offset = _spine_slider_data_get_offsetPtr
      .asFunction<double Function(spine_slider_data)>();

  void spine_slider_data_set_offset(
    spine_slider_data self,
    double offset,
  ) {
    return _spine_slider_data_set_offset(
      self,
      offset,
    );
  }

  late final _spine_slider_data_set_offsetPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_slider_data, ffi.Float)>>(
      'spine_slider_data_set_offset');
  late final _spine_slider_data_set_offset = _spine_slider_data_set_offsetPtr
      .asFunction<void Function(spine_slider_data, double)>();

  bool spine_slider_data_get_local(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_local(
      self,
    );
  }

  late final _spine_slider_data_get_localPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider_data)>>(
          'spine_slider_data_get_local');
  late final _spine_slider_data_get_local = _spine_slider_data_get_localPtr
      .asFunction<bool Function(spine_slider_data)>();

  void spine_slider_data_set_local(
    spine_slider_data self,
    bool local,
  ) {
    return _spine_slider_data_set_local(
      self,
      local,
    );
  }

  late final _spine_slider_data_set_localPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_slider_data, ffi.Bool)>>(
      'spine_slider_data_set_local');
  late final _spine_slider_data_set_local = _spine_slider_data_set_localPtr
      .asFunction<void Function(spine_slider_data, bool)>();

  ffi.Pointer<ffi.Char> spine_slider_data_get_name(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_name(
      self,
    );
  }

  late final _spine_slider_data_get_namePtr = _lookup<
          ffi
          .NativeFunction<ffi.Pointer<ffi.Char> Function(spine_slider_data)>>(
      'spine_slider_data_get_name');
  late final _spine_slider_data_get_name = _spine_slider_data_get_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_slider_data)>();

  bool spine_slider_data_get_skin_required(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_skin_required(
      self,
    );
  }

  late final _spine_slider_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slider_data)>>(
          'spine_slider_data_get_skin_required');
  late final _spine_slider_data_get_skin_required =
      _spine_slider_data_get_skin_requiredPtr
          .asFunction<bool Function(spine_slider_data)>();

  spine_slider_pose spine_slider_data_get_setup_pose(
    spine_slider_data self,
  ) {
    return _spine_slider_data_get_setup_pose(
      self,
    );
  }

  late final _spine_slider_data_get_setup_posePtr = _lookup<
          ffi.NativeFunction<spine_slider_pose Function(spine_slider_data)>>(
      'spine_slider_data_get_setup_pose');
  late final _spine_slider_data_get_setup_pose =
      _spine_slider_data_get_setup_posePtr
          .asFunction<spine_slider_pose Function(spine_slider_data)>();

  void spine_slider_data_set_skin_required(
    spine_slider_data self,
    bool skinRequired,
  ) {
    return _spine_slider_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_slider_data_set_skin_requiredPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_slider_data, ffi.Bool)>>(
      'spine_slider_data_set_skin_required');
  late final _spine_slider_data_set_skin_required =
      _spine_slider_data_set_skin_requiredPtr
          .asFunction<void Function(spine_slider_data, bool)>();

  spine_rtti spine_slider_data_rtti() {
    return _spine_slider_data_rtti();
  }

  late final _spine_slider_data_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_slider_data_rtti');
  late final _spine_slider_data_rtti =
      _spine_slider_data_rttiPtr.asFunction<spine_rtti Function()>();

  spine_slider_mix_timeline spine_slider_mix_timeline_create(
    int frameCount,
    int bezierCount,
    int sliderIndex,
  ) {
    return _spine_slider_mix_timeline_create(
      frameCount,
      bezierCount,
      sliderIndex,
    );
  }

  late final _spine_slider_mix_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_slider_mix_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_slider_mix_timeline_create');
  late final _spine_slider_mix_timeline_create =
      _spine_slider_mix_timeline_createPtr
          .asFunction<spine_slider_mix_timeline Function(int, int, int)>();

  void spine_slider_mix_timeline_dispose(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_dispose(
      self,
    );
  }

  late final _spine_slider_mix_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_dispose');
  late final _spine_slider_mix_timeline_dispose =
      _spine_slider_mix_timeline_disposePtr
          .asFunction<void Function(spine_slider_mix_timeline)>();

  spine_rtti spine_slider_mix_timeline_get_rtti(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_rtti(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_slider_mix_timeline)>>(
      'spine_slider_mix_timeline_get_rtti');
  late final _spine_slider_mix_timeline_get_rtti =
      _spine_slider_mix_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_slider_mix_timeline)>();

  void spine_slider_mix_timeline_apply(
    spine_slider_mix_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_slider_mix_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_slider_mix_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_slider_mix_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_slider_mix_timeline_apply');
  late final _spine_slider_mix_timeline_apply =
      _spine_slider_mix_timeline_applyPtr.asFunction<
          void Function(spine_slider_mix_timeline, spine_skeleton, double,
              double, spine_array_event, double, int, int, bool)>();

  void spine_slider_mix_timeline_set_frame(
    spine_slider_mix_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_slider_mix_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_slider_mix_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slider_mix_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_slider_mix_timeline_set_frame');
  late final _spine_slider_mix_timeline_set_frame =
      _spine_slider_mix_timeline_set_framePtr.asFunction<
          void Function(spine_slider_mix_timeline, int, double, double)>();

  double spine_slider_mix_timeline_get_curve_value(
    spine_slider_mix_timeline self,
    double time,
  ) {
    return _spine_slider_mix_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_slider_mix_timeline_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_slider_mix_timeline,
              ffi.Float)>>('spine_slider_mix_timeline_get_curve_value');
  late final _spine_slider_mix_timeline_get_curve_value =
      _spine_slider_mix_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_slider_mix_timeline, double)>();

  double spine_slider_mix_timeline_get_relative_value(
    spine_slider_mix_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_slider_mix_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_slider_mix_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_slider_mix_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_slider_mix_timeline_get_relative_value');
  late final _spine_slider_mix_timeline_get_relative_value =
      _spine_slider_mix_timeline_get_relative_valuePtr.asFunction<
          double Function(spine_slider_mix_timeline, double, double, int,
              double, double)>();

  double spine_slider_mix_timeline_get_absolute_value_1(
    spine_slider_mix_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_slider_mix_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_slider_mix_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_slider_mix_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_slider_mix_timeline_get_absolute_value_1');
  late final _spine_slider_mix_timeline_get_absolute_value_1 =
      _spine_slider_mix_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(spine_slider_mix_timeline, double, double, int,
              double, double)>();

  double spine_slider_mix_timeline_get_absolute_value_2(
    spine_slider_mix_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_slider_mix_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_slider_mix_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_slider_mix_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_slider_mix_timeline_get_absolute_value_2');
  late final _spine_slider_mix_timeline_get_absolute_value_2 =
      _spine_slider_mix_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_slider_mix_timeline, double, double, int,
              double, double, double)>();

  double spine_slider_mix_timeline_get_scale_value(
    spine_slider_mix_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_slider_mix_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_slider_mix_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_slider_mix_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_slider_mix_timeline_get_scale_value');
  late final _spine_slider_mix_timeline_get_scale_value =
      _spine_slider_mix_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_slider_mix_timeline, double, double, int, int,
              double, double)>();

  void spine_slider_mix_timeline_set_linear(
    spine_slider_mix_timeline self,
    int frame,
  ) {
    return _spine_slider_mix_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_slider_mix_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slider_mix_timeline,
              ffi.Size)>>('spine_slider_mix_timeline_set_linear');
  late final _spine_slider_mix_timeline_set_linear =
      _spine_slider_mix_timeline_set_linearPtr
          .asFunction<void Function(spine_slider_mix_timeline, int)>();

  void spine_slider_mix_timeline_set_stepped(
    spine_slider_mix_timeline self,
    int frame,
  ) {
    return _spine_slider_mix_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_slider_mix_timeline_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slider_mix_timeline,
              ffi.Size)>>('spine_slider_mix_timeline_set_stepped');
  late final _spine_slider_mix_timeline_set_stepped =
      _spine_slider_mix_timeline_set_steppedPtr
          .asFunction<void Function(spine_slider_mix_timeline, int)>();

  void spine_slider_mix_timeline_set_bezier(
    spine_slider_mix_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_slider_mix_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_slider_mix_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_slider_mix_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_slider_mix_timeline_set_bezier');
  late final _spine_slider_mix_timeline_set_bezier =
      _spine_slider_mix_timeline_set_bezierPtr.asFunction<
          void Function(spine_slider_mix_timeline, int, int, double, double,
              double, double, double, double, double, double, double)>();

  double spine_slider_mix_timeline_get_bezier_value(
    spine_slider_mix_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_slider_mix_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_slider_mix_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_slider_mix_timeline,
              ffi.Float,
              ffi.Size,
              ffi.Size,
              ffi.Size)>>('spine_slider_mix_timeline_get_bezier_value');
  late final _spine_slider_mix_timeline_get_bezier_value =
      _spine_slider_mix_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_slider_mix_timeline, double, int, int, int)>();

  spine_array_float spine_slider_mix_timeline_get_curves(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_curves(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_slider_mix_timeline)>>(
      'spine_slider_mix_timeline_get_curves');
  late final _spine_slider_mix_timeline_get_curves =
      _spine_slider_mix_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_slider_mix_timeline)>();

  int spine_slider_mix_timeline_get_frame_entries(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_get_frame_entries');
  late final _spine_slider_mix_timeline_get_frame_entries =
      _spine_slider_mix_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_slider_mix_timeline)>();

  int spine_slider_mix_timeline_get_frame_count(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_get_frame_count');
  late final _spine_slider_mix_timeline_get_frame_count =
      _spine_slider_mix_timeline_get_frame_countPtr
          .asFunction<int Function(spine_slider_mix_timeline)>();

  spine_array_float spine_slider_mix_timeline_get_frames(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_frames(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_slider_mix_timeline)>>(
      'spine_slider_mix_timeline_get_frames');
  late final _spine_slider_mix_timeline_get_frames =
      _spine_slider_mix_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_slider_mix_timeline)>();

  double spine_slider_mix_timeline_get_duration(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_duration(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_slider_mix_timeline)>>(
      'spine_slider_mix_timeline_get_duration');
  late final _spine_slider_mix_timeline_get_duration =
      _spine_slider_mix_timeline_get_durationPtr
          .asFunction<double Function(spine_slider_mix_timeline)>();

  spine_array_property_id spine_slider_mix_timeline_get_property_ids(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_slider_mix_timeline)>>(
      'spine_slider_mix_timeline_get_property_ids');
  late final _spine_slider_mix_timeline_get_property_ids =
      _spine_slider_mix_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_slider_mix_timeline)>();

  int spine_slider_mix_timeline_get_constraint_index(
    spine_slider_mix_timeline self,
  ) {
    return _spine_slider_mix_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_slider_mix_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_slider_mix_timeline)>>(
          'spine_slider_mix_timeline_get_constraint_index');
  late final _spine_slider_mix_timeline_get_constraint_index =
      _spine_slider_mix_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_slider_mix_timeline)>();

  void spine_slider_mix_timeline_set_constraint_index(
    spine_slider_mix_timeline self,
    int inValue,
  ) {
    return _spine_slider_mix_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_slider_mix_timeline_set_constraint_indexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slider_mix_timeline,
              ffi.Int)>>('spine_slider_mix_timeline_set_constraint_index');
  late final _spine_slider_mix_timeline_set_constraint_index =
      _spine_slider_mix_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_slider_mix_timeline, int)>();

  spine_rtti spine_slider_mix_timeline_rtti() {
    return _spine_slider_mix_timeline_rtti();
  }

  late final _spine_slider_mix_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_slider_mix_timeline_rtti');
  late final _spine_slider_mix_timeline_rtti =
      _spine_slider_mix_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_slider_pose spine_slider_pose_create() {
    return _spine_slider_pose_create();
  }

  late final _spine_slider_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_slider_pose Function()>>(
          'spine_slider_pose_create');
  late final _spine_slider_pose_create =
      _spine_slider_pose_createPtr.asFunction<spine_slider_pose Function()>();

  void spine_slider_pose_dispose(
    spine_slider_pose self,
  ) {
    return _spine_slider_pose_dispose(
      self,
    );
  }

  late final _spine_slider_pose_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_pose)>>(
          'spine_slider_pose_dispose');
  late final _spine_slider_pose_dispose = _spine_slider_pose_disposePtr
      .asFunction<void Function(spine_slider_pose)>();

  void spine_slider_pose_set(
    spine_slider_pose self,
    spine_slider_pose pose,
  ) {
    return _spine_slider_pose_set(
      self,
      pose,
    );
  }

  late final _spine_slider_pose_setPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_slider_pose, spine_slider_pose)>>('spine_slider_pose_set');
  late final _spine_slider_pose_set = _spine_slider_pose_setPtr
      .asFunction<void Function(spine_slider_pose, spine_slider_pose)>();

  double spine_slider_pose_get_time(
    spine_slider_pose self,
  ) {
    return _spine_slider_pose_get_time(
      self,
    );
  }

  late final _spine_slider_pose_get_timePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_pose)>>(
          'spine_slider_pose_get_time');
  late final _spine_slider_pose_get_time = _spine_slider_pose_get_timePtr
      .asFunction<double Function(spine_slider_pose)>();

  void spine_slider_pose_set_time(
    spine_slider_pose self,
    double time,
  ) {
    return _spine_slider_pose_set_time(
      self,
      time,
    );
  }

  late final _spine_slider_pose_set_timePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_slider_pose, ffi.Float)>>(
      'spine_slider_pose_set_time');
  late final _spine_slider_pose_set_time = _spine_slider_pose_set_timePtr
      .asFunction<void Function(spine_slider_pose, double)>();

  double spine_slider_pose_get_mix(
    spine_slider_pose self,
  ) {
    return _spine_slider_pose_get_mix(
      self,
    );
  }

  late final _spine_slider_pose_get_mixPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_pose)>>(
          'spine_slider_pose_get_mix');
  late final _spine_slider_pose_get_mix = _spine_slider_pose_get_mixPtr
      .asFunction<double Function(spine_slider_pose)>();

  void spine_slider_pose_set_mix(
    spine_slider_pose self,
    double mix,
  ) {
    return _spine_slider_pose_set_mix(
      self,
      mix,
    );
  }

  late final _spine_slider_pose_set_mixPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_slider_pose, ffi.Float)>>(
      'spine_slider_pose_set_mix');
  late final _spine_slider_pose_set_mix = _spine_slider_pose_set_mixPtr
      .asFunction<void Function(spine_slider_pose, double)>();

  spine_slider_timeline spine_slider_timeline_create(
    int frameCount,
    int bezierCount,
    int sliderIndex,
  ) {
    return _spine_slider_timeline_create(
      frameCount,
      bezierCount,
      sliderIndex,
    );
  }

  late final _spine_slider_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_slider_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_slider_timeline_create');
  late final _spine_slider_timeline_create = _spine_slider_timeline_createPtr
      .asFunction<spine_slider_timeline Function(int, int, int)>();

  void spine_slider_timeline_dispose(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_dispose(
      self,
    );
  }

  late final _spine_slider_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slider_timeline)>>(
          'spine_slider_timeline_dispose');
  late final _spine_slider_timeline_dispose = _spine_slider_timeline_disposePtr
      .asFunction<void Function(spine_slider_timeline)>();

  spine_rtti spine_slider_timeline_get_rtti(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_rtti(
      self,
    );
  }

  late final _spine_slider_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_slider_timeline)>>(
          'spine_slider_timeline_get_rtti');
  late final _spine_slider_timeline_get_rtti =
      _spine_slider_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_slider_timeline)>();

  void spine_slider_timeline_apply(
    spine_slider_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_slider_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_slider_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_slider_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_slider_timeline_apply');
  late final _spine_slider_timeline_apply =
      _spine_slider_timeline_applyPtr.asFunction<
          void Function(spine_slider_timeline, spine_skeleton, double, double,
              spine_array_event, double, int, int, bool)>();

  void spine_slider_timeline_set_frame(
    spine_slider_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_slider_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_slider_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slider_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_slider_timeline_set_frame');
  late final _spine_slider_timeline_set_frame =
      _spine_slider_timeline_set_framePtr.asFunction<
          void Function(spine_slider_timeline, int, double, double)>();

  double spine_slider_timeline_get_curve_value(
    spine_slider_timeline self,
    double time,
  ) {
    return _spine_slider_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_slider_timeline_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_slider_timeline,
              ffi.Float)>>('spine_slider_timeline_get_curve_value');
  late final _spine_slider_timeline_get_curve_value =
      _spine_slider_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_slider_timeline, double)>();

  double spine_slider_timeline_get_relative_value(
    spine_slider_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_slider_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_slider_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_slider_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_slider_timeline_get_relative_value');
  late final _spine_slider_timeline_get_relative_value =
      _spine_slider_timeline_get_relative_valuePtr.asFunction<
          double Function(
              spine_slider_timeline, double, double, int, double, double)>();

  double spine_slider_timeline_get_absolute_value_1(
    spine_slider_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_slider_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_slider_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_slider_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_slider_timeline_get_absolute_value_1');
  late final _spine_slider_timeline_get_absolute_value_1 =
      _spine_slider_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(
              spine_slider_timeline, double, double, int, double, double)>();

  double spine_slider_timeline_get_absolute_value_2(
    spine_slider_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_slider_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_slider_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_slider_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_slider_timeline_get_absolute_value_2');
  late final _spine_slider_timeline_get_absolute_value_2 =
      _spine_slider_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_slider_timeline, double, double, int, double,
              double, double)>();

  double spine_slider_timeline_get_scale_value(
    spine_slider_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_slider_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_slider_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_slider_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_slider_timeline_get_scale_value');
  late final _spine_slider_timeline_get_scale_value =
      _spine_slider_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_slider_timeline, double, double, int, int,
              double, double)>();

  void spine_slider_timeline_set_linear(
    spine_slider_timeline self,
    int frame,
  ) {
    return _spine_slider_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_slider_timeline_set_linearPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_slider_timeline, ffi.Size)>>(
      'spine_slider_timeline_set_linear');
  late final _spine_slider_timeline_set_linear =
      _spine_slider_timeline_set_linearPtr
          .asFunction<void Function(spine_slider_timeline, int)>();

  void spine_slider_timeline_set_stepped(
    spine_slider_timeline self,
    int frame,
  ) {
    return _spine_slider_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_slider_timeline_set_steppedPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_slider_timeline, ffi.Size)>>(
      'spine_slider_timeline_set_stepped');
  late final _spine_slider_timeline_set_stepped =
      _spine_slider_timeline_set_steppedPtr
          .asFunction<void Function(spine_slider_timeline, int)>();

  void spine_slider_timeline_set_bezier(
    spine_slider_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_slider_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_slider_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_slider_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_slider_timeline_set_bezier');
  late final _spine_slider_timeline_set_bezier =
      _spine_slider_timeline_set_bezierPtr.asFunction<
          void Function(spine_slider_timeline, int, int, double, double, double,
              double, double, double, double, double, double)>();

  double spine_slider_timeline_get_bezier_value(
    spine_slider_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_slider_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_slider_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_slider_timeline, ffi.Float, ffi.Size,
              ffi.Size, ffi.Size)>>('spine_slider_timeline_get_bezier_value');
  late final _spine_slider_timeline_get_bezier_value =
      _spine_slider_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_slider_timeline, double, int, int, int)>();

  spine_array_float spine_slider_timeline_get_curves(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_curves(
      self,
    );
  }

  late final _spine_slider_timeline_get_curvesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_slider_timeline)>>(
      'spine_slider_timeline_get_curves');
  late final _spine_slider_timeline_get_curves =
      _spine_slider_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_slider_timeline)>();

  int spine_slider_timeline_get_frame_entries(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_slider_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_slider_timeline)>>(
          'spine_slider_timeline_get_frame_entries');
  late final _spine_slider_timeline_get_frame_entries =
      _spine_slider_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_slider_timeline)>();

  int spine_slider_timeline_get_frame_count(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_slider_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_slider_timeline)>>(
          'spine_slider_timeline_get_frame_count');
  late final _spine_slider_timeline_get_frame_count =
      _spine_slider_timeline_get_frame_countPtr
          .asFunction<int Function(spine_slider_timeline)>();

  spine_array_float spine_slider_timeline_get_frames(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_frames(
      self,
    );
  }

  late final _spine_slider_timeline_get_framesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_slider_timeline)>>(
      'spine_slider_timeline_get_frames');
  late final _spine_slider_timeline_get_frames =
      _spine_slider_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_slider_timeline)>();

  double spine_slider_timeline_get_duration(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_duration(
      self,
    );
  }

  late final _spine_slider_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_slider_timeline)>>(
          'spine_slider_timeline_get_duration');
  late final _spine_slider_timeline_get_duration =
      _spine_slider_timeline_get_durationPtr
          .asFunction<double Function(spine_slider_timeline)>();

  spine_array_property_id spine_slider_timeline_get_property_ids(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_slider_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_slider_timeline)>>(
      'spine_slider_timeline_get_property_ids');
  late final _spine_slider_timeline_get_property_ids =
      _spine_slider_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_slider_timeline)>();

  int spine_slider_timeline_get_constraint_index(
    spine_slider_timeline self,
  ) {
    return _spine_slider_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_slider_timeline_get_constraint_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_slider_timeline)>>(
          'spine_slider_timeline_get_constraint_index');
  late final _spine_slider_timeline_get_constraint_index =
      _spine_slider_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_slider_timeline)>();

  void spine_slider_timeline_set_constraint_index(
    spine_slider_timeline self,
    int inValue,
  ) {
    return _spine_slider_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_slider_timeline_set_constraint_indexPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_slider_timeline, ffi.Int)>>(
      'spine_slider_timeline_set_constraint_index');
  late final _spine_slider_timeline_set_constraint_index =
      _spine_slider_timeline_set_constraint_indexPtr
          .asFunction<void Function(spine_slider_timeline, int)>();

  spine_rtti spine_slider_timeline_rtti() {
    return _spine_slider_timeline_rtti();
  }

  late final _spine_slider_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_slider_timeline_rtti');
  late final _spine_slider_timeline_rtti =
      _spine_slider_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_slot spine_slot_create(
    spine_slot_data data,
    spine_skeleton skeleton,
  ) {
    return _spine_slot_create(
      data,
      skeleton,
    );
  }

  late final _spine_slot_createPtr = _lookup<
      ffi.NativeFunction<
          spine_slot Function(
              spine_slot_data, spine_skeleton)>>('spine_slot_create');
  late final _spine_slot_create = _spine_slot_createPtr
      .asFunction<spine_slot Function(spine_slot_data, spine_skeleton)>();

  void spine_slot_dispose(
    spine_slot self,
  ) {
    return _spine_slot_dispose(
      self,
    );
  }

  late final _spine_slot_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot)>>(
          'spine_slot_dispose');
  late final _spine_slot_dispose =
      _spine_slot_disposePtr.asFunction<void Function(spine_slot)>();

  spine_bone spine_slot_get_bone(
    spine_slot self,
  ) {
    return _spine_slot_get_bone(
      self,
    );
  }

  late final _spine_slot_get_bonePtr =
      _lookup<ffi.NativeFunction<spine_bone Function(spine_slot)>>(
          'spine_slot_get_bone');
  late final _spine_slot_get_bone =
      _spine_slot_get_bonePtr.asFunction<spine_bone Function(spine_slot)>();

  void spine_slot_setup_pose(
    spine_slot self,
  ) {
    return _spine_slot_setup_pose(
      self,
    );
  }

  late final _spine_slot_setup_posePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot)>>(
          'spine_slot_setup_pose');
  late final _spine_slot_setup_pose =
      _spine_slot_setup_posePtr.asFunction<void Function(spine_slot)>();

  spine_slot_data spine_slot_get_data(
    spine_slot self,
  ) {
    return _spine_slot_get_data(
      self,
    );
  }

  late final _spine_slot_get_dataPtr =
      _lookup<ffi.NativeFunction<spine_slot_data Function(spine_slot)>>(
          'spine_slot_get_data');
  late final _spine_slot_get_data = _spine_slot_get_dataPtr
      .asFunction<spine_slot_data Function(spine_slot)>();

  spine_slot_pose spine_slot_get_pose(
    spine_slot self,
  ) {
    return _spine_slot_get_pose(
      self,
    );
  }

  late final _spine_slot_get_posePtr =
      _lookup<ffi.NativeFunction<spine_slot_pose Function(spine_slot)>>(
          'spine_slot_get_pose');
  late final _spine_slot_get_pose = _spine_slot_get_posePtr
      .asFunction<spine_slot_pose Function(spine_slot)>();

  spine_slot_pose spine_slot_get_applied_pose(
    spine_slot self,
  ) {
    return _spine_slot_get_applied_pose(
      self,
    );
  }

  late final _spine_slot_get_applied_posePtr =
      _lookup<ffi.NativeFunction<spine_slot_pose Function(spine_slot)>>(
          'spine_slot_get_applied_pose');
  late final _spine_slot_get_applied_pose = _spine_slot_get_applied_posePtr
      .asFunction<spine_slot_pose Function(spine_slot)>();

  void spine_slot_reset_constrained(
    spine_slot self,
  ) {
    return _spine_slot_reset_constrained(
      self,
    );
  }

  late final _spine_slot_reset_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot)>>(
          'spine_slot_reset_constrained');
  late final _spine_slot_reset_constrained =
      _spine_slot_reset_constrainedPtr.asFunction<void Function(spine_slot)>();

  void spine_slot_constrained(
    spine_slot self,
  ) {
    return _spine_slot_constrained(
      self,
    );
  }

  late final _spine_slot_constrainedPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot)>>(
          'spine_slot_constrained');
  late final _spine_slot_constrained =
      _spine_slot_constrainedPtr.asFunction<void Function(spine_slot)>();

  bool spine_slot_is_pose_equal_to_applied(
    spine_slot self,
  ) {
    return _spine_slot_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_slot_is_pose_equal_to_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slot)>>(
          'spine_slot_is_pose_equal_to_applied');
  late final _spine_slot_is_pose_equal_to_applied =
      _spine_slot_is_pose_equal_to_appliedPtr
          .asFunction<bool Function(spine_slot)>();

  void spine_slot_curve_timeline_dispose(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_dispose(
      self,
    );
  }

  late final _spine_slot_curve_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_dispose');
  late final _spine_slot_curve_timeline_dispose =
      _spine_slot_curve_timeline_disposePtr
          .asFunction<void Function(spine_slot_curve_timeline)>();

  spine_rtti spine_slot_curve_timeline_get_rtti(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_rtti(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_slot_curve_timeline)>>(
      'spine_slot_curve_timeline_get_rtti');
  late final _spine_slot_curve_timeline_get_rtti =
      _spine_slot_curve_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_slot_curve_timeline)>();

  void spine_slot_curve_timeline_apply(
    spine_slot_curve_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_slot_curve_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_slot_curve_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_slot_curve_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_slot_curve_timeline_apply');
  late final _spine_slot_curve_timeline_apply =
      _spine_slot_curve_timeline_applyPtr.asFunction<
          void Function(spine_slot_curve_timeline, spine_skeleton, double,
              double, spine_array_event, double, int, int, bool)>();

  void spine_slot_curve_timeline_set_linear(
    spine_slot_curve_timeline self,
    int frame,
  ) {
    return _spine_slot_curve_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_slot_curve_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slot_curve_timeline,
              ffi.Size)>>('spine_slot_curve_timeline_set_linear');
  late final _spine_slot_curve_timeline_set_linear =
      _spine_slot_curve_timeline_set_linearPtr
          .asFunction<void Function(spine_slot_curve_timeline, int)>();

  void spine_slot_curve_timeline_set_stepped(
    spine_slot_curve_timeline self,
    int frame,
  ) {
    return _spine_slot_curve_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_slot_curve_timeline_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slot_curve_timeline,
              ffi.Size)>>('spine_slot_curve_timeline_set_stepped');
  late final _spine_slot_curve_timeline_set_stepped =
      _spine_slot_curve_timeline_set_steppedPtr
          .asFunction<void Function(spine_slot_curve_timeline, int)>();

  void spine_slot_curve_timeline_set_bezier(
    spine_slot_curve_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_slot_curve_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_slot_curve_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_slot_curve_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_slot_curve_timeline_set_bezier');
  late final _spine_slot_curve_timeline_set_bezier =
      _spine_slot_curve_timeline_set_bezierPtr.asFunction<
          void Function(spine_slot_curve_timeline, int, int, double, double,
              double, double, double, double, double, double, double)>();

  double spine_slot_curve_timeline_get_bezier_value(
    spine_slot_curve_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_slot_curve_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_slot_curve_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_slot_curve_timeline,
              ffi.Float,
              ffi.Size,
              ffi.Size,
              ffi.Size)>>('spine_slot_curve_timeline_get_bezier_value');
  late final _spine_slot_curve_timeline_get_bezier_value =
      _spine_slot_curve_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_slot_curve_timeline, double, int, int, int)>();

  spine_array_float spine_slot_curve_timeline_get_curves(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_curves(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_slot_curve_timeline)>>(
      'spine_slot_curve_timeline_get_curves');
  late final _spine_slot_curve_timeline_get_curves =
      _spine_slot_curve_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_slot_curve_timeline)>();

  int spine_slot_curve_timeline_get_frame_entries(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_get_frame_entries');
  late final _spine_slot_curve_timeline_get_frame_entries =
      _spine_slot_curve_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_slot_curve_timeline)>();

  int spine_slot_curve_timeline_get_frame_count(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_get_frame_count');
  late final _spine_slot_curve_timeline_get_frame_count =
      _spine_slot_curve_timeline_get_frame_countPtr
          .asFunction<int Function(spine_slot_curve_timeline)>();

  spine_array_float spine_slot_curve_timeline_get_frames(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_frames(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_slot_curve_timeline)>>(
      'spine_slot_curve_timeline_get_frames');
  late final _spine_slot_curve_timeline_get_frames =
      _spine_slot_curve_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_slot_curve_timeline)>();

  double spine_slot_curve_timeline_get_duration(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_duration(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_slot_curve_timeline)>>(
      'spine_slot_curve_timeline_get_duration');
  late final _spine_slot_curve_timeline_get_duration =
      _spine_slot_curve_timeline_get_durationPtr
          .asFunction<double Function(spine_slot_curve_timeline)>();

  spine_array_property_id spine_slot_curve_timeline_get_property_ids(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_slot_curve_timeline)>>(
      'spine_slot_curve_timeline_get_property_ids');
  late final _spine_slot_curve_timeline_get_property_ids =
      _spine_slot_curve_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_slot_curve_timeline)>();

  int spine_slot_curve_timeline_get_slot_index(
    spine_slot_curve_timeline self,
  ) {
    return _spine_slot_curve_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_slot_curve_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_slot_curve_timeline)>>(
          'spine_slot_curve_timeline_get_slot_index');
  late final _spine_slot_curve_timeline_get_slot_index =
      _spine_slot_curve_timeline_get_slot_indexPtr
          .asFunction<int Function(spine_slot_curve_timeline)>();

  void spine_slot_curve_timeline_set_slot_index(
    spine_slot_curve_timeline self,
    int inValue,
  ) {
    return _spine_slot_curve_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_slot_curve_timeline_set_slot_indexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slot_curve_timeline,
              ffi.Int)>>('spine_slot_curve_timeline_set_slot_index');
  late final _spine_slot_curve_timeline_set_slot_index =
      _spine_slot_curve_timeline_set_slot_indexPtr
          .asFunction<void Function(spine_slot_curve_timeline, int)>();

  spine_rtti spine_slot_curve_timeline_rtti() {
    return _spine_slot_curve_timeline_rtti();
  }

  late final _spine_slot_curve_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_slot_curve_timeline_rtti');
  late final _spine_slot_curve_timeline_rtti =
      _spine_slot_curve_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_slot_data spine_slot_data_create(
    int index,
    ffi.Pointer<ffi.Char> name,
    spine_bone_data boneData,
  ) {
    return _spine_slot_data_create(
      index,
      name,
      boneData,
    );
  }

  late final _spine_slot_data_createPtr = _lookup<
      ffi.NativeFunction<
          spine_slot_data Function(ffi.Int, ffi.Pointer<ffi.Char>,
              spine_bone_data)>>('spine_slot_data_create');
  late final _spine_slot_data_create = _spine_slot_data_createPtr.asFunction<
      spine_slot_data Function(int, ffi.Pointer<ffi.Char>, spine_bone_data)>();

  void spine_slot_data_dispose(
    spine_slot_data self,
  ) {
    return _spine_slot_data_dispose(
      self,
    );
  }

  late final _spine_slot_data_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data)>>(
          'spine_slot_data_dispose');
  late final _spine_slot_data_dispose =
      _spine_slot_data_disposePtr.asFunction<void Function(spine_slot_data)>();

  int spine_slot_data_get_index(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_index(
      self,
    );
  }

  late final _spine_slot_data_get_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_slot_data)>>(
          'spine_slot_data_get_index');
  late final _spine_slot_data_get_index =
      _spine_slot_data_get_indexPtr.asFunction<int Function(spine_slot_data)>();

  spine_bone_data spine_slot_data_get_bone_data(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_bone_data(
      self,
    );
  }

  late final _spine_slot_data_get_bone_dataPtr =
      _lookup<ffi.NativeFunction<spine_bone_data Function(spine_slot_data)>>(
          'spine_slot_data_get_bone_data');
  late final _spine_slot_data_get_bone_data = _spine_slot_data_get_bone_dataPtr
      .asFunction<spine_bone_data Function(spine_slot_data)>();

  void spine_slot_data_set_attachment_name(
    spine_slot_data self,
    ffi.Pointer<ffi.Char> attachmentName,
  ) {
    return _spine_slot_data_set_attachment_name(
      self,
      attachmentName,
    );
  }

  late final _spine_slot_data_set_attachment_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slot_data,
              ffi.Pointer<ffi.Char>)>>('spine_slot_data_set_attachment_name');
  late final _spine_slot_data_set_attachment_name =
      _spine_slot_data_set_attachment_namePtr
          .asFunction<void Function(spine_slot_data, ffi.Pointer<ffi.Char>)>();

  ffi.Pointer<ffi.Char> spine_slot_data_get_attachment_name(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_attachment_name(
      self,
    );
  }

  late final _spine_slot_data_get_attachment_namePtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_slot_data)>>(
      'spine_slot_data_get_attachment_name');
  late final _spine_slot_data_get_attachment_name =
      _spine_slot_data_get_attachment_namePtr
          .asFunction<ffi.Pointer<ffi.Char> Function(spine_slot_data)>();

  int spine_slot_data_get_blend_mode(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_blend_mode(
      self,
    );
  }

  late final _spine_slot_data_get_blend_modePtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_slot_data)>>(
          'spine_slot_data_get_blend_mode');
  late final _spine_slot_data_get_blend_mode =
      _spine_slot_data_get_blend_modePtr
          .asFunction<int Function(spine_slot_data)>();

  void spine_slot_data_set_blend_mode(
    spine_slot_data self,
    int blendMode,
  ) {
    return _spine_slot_data_set_blend_mode(
      self,
      blendMode,
    );
  }

  late final _spine_slot_data_set_blend_modePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Int32)>>(
      'spine_slot_data_set_blend_mode');
  late final _spine_slot_data_set_blend_mode =
      _spine_slot_data_set_blend_modePtr
          .asFunction<void Function(spine_slot_data, int)>();

  bool spine_slot_data_get_visible(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_visible(
      self,
    );
  }

  late final _spine_slot_data_get_visiblePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slot_data)>>(
          'spine_slot_data_get_visible');
  late final _spine_slot_data_get_visible = _spine_slot_data_get_visiblePtr
      .asFunction<bool Function(spine_slot_data)>();

  void spine_slot_data_set_visible(
    spine_slot_data self,
    bool visible,
  ) {
    return _spine_slot_data_set_visible(
      self,
      visible,
    );
  }

  late final _spine_slot_data_set_visiblePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Bool)>>(
          'spine_slot_data_set_visible');
  late final _spine_slot_data_set_visible = _spine_slot_data_set_visiblePtr
      .asFunction<void Function(spine_slot_data, bool)>();

  spine_slot_pose spine_slot_data_get_setup_pose(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_setup_pose(
      self,
    );
  }

  late final _spine_slot_data_get_setup_posePtr =
      _lookup<ffi.NativeFunction<spine_slot_pose Function(spine_slot_data)>>(
          'spine_slot_data_get_setup_pose');
  late final _spine_slot_data_get_setup_pose =
      _spine_slot_data_get_setup_posePtr
          .asFunction<spine_slot_pose Function(spine_slot_data)>();

  ffi.Pointer<ffi.Char> spine_slot_data_get_name(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_name(
      self,
    );
  }

  late final _spine_slot_data_get_namePtr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(spine_slot_data)>>(
      'spine_slot_data_get_name');
  late final _spine_slot_data_get_name = _spine_slot_data_get_namePtr
      .asFunction<ffi.Pointer<ffi.Char> Function(spine_slot_data)>();

  bool spine_slot_data_get_skin_required(
    spine_slot_data self,
  ) {
    return _spine_slot_data_get_skin_required(
      self,
    );
  }

  late final _spine_slot_data_get_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slot_data)>>(
          'spine_slot_data_get_skin_required');
  late final _spine_slot_data_get_skin_required =
      _spine_slot_data_get_skin_requiredPtr
          .asFunction<bool Function(spine_slot_data)>();

  void spine_slot_data_set_skin_required(
    spine_slot_data self,
    bool skinRequired,
  ) {
    return _spine_slot_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_slot_data_set_skin_requiredPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Bool)>>(
          'spine_slot_data_set_skin_required');
  late final _spine_slot_data_set_skin_required =
      _spine_slot_data_set_skin_requiredPtr
          .asFunction<void Function(spine_slot_data, bool)>();

  spine_slot_pose spine_slot_pose_create() {
    return _spine_slot_pose_create();
  }

  late final _spine_slot_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_slot_pose Function()>>(
          'spine_slot_pose_create');
  late final _spine_slot_pose_create =
      _spine_slot_pose_createPtr.asFunction<spine_slot_pose Function()>();

  void spine_slot_pose_dispose(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_dispose(
      self,
    );
  }

  late final _spine_slot_pose_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_pose)>>(
          'spine_slot_pose_dispose');
  late final _spine_slot_pose_dispose =
      _spine_slot_pose_disposePtr.asFunction<void Function(spine_slot_pose)>();

  void spine_slot_pose_set(
    spine_slot_pose self,
    spine_slot_pose pose,
  ) {
    return _spine_slot_pose_set(
      self,
      pose,
    );
  }

  late final _spine_slot_pose_setPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_slot_pose, spine_slot_pose)>>(
      'spine_slot_pose_set');
  late final _spine_slot_pose_set = _spine_slot_pose_setPtr
      .asFunction<void Function(spine_slot_pose, spine_slot_pose)>();

  spine_color spine_slot_pose_get_color(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_get_color(
      self,
    );
  }

  late final _spine_slot_pose_get_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_slot_pose)>>(
          'spine_slot_pose_get_color');
  late final _spine_slot_pose_get_color = _spine_slot_pose_get_colorPtr
      .asFunction<spine_color Function(spine_slot_pose)>();

  spine_color spine_slot_pose_get_dark_color(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_get_dark_color(
      self,
    );
  }

  late final _spine_slot_pose_get_dark_colorPtr =
      _lookup<ffi.NativeFunction<spine_color Function(spine_slot_pose)>>(
          'spine_slot_pose_get_dark_color');
  late final _spine_slot_pose_get_dark_color =
      _spine_slot_pose_get_dark_colorPtr
          .asFunction<spine_color Function(spine_slot_pose)>();

  bool spine_slot_pose_has_dark_color(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_has_dark_color(
      self,
    );
  }

  late final _spine_slot_pose_has_dark_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_slot_pose)>>(
          'spine_slot_pose_has_dark_color');
  late final _spine_slot_pose_has_dark_color =
      _spine_slot_pose_has_dark_colorPtr
          .asFunction<bool Function(spine_slot_pose)>();

  void spine_slot_pose_set_has_dark_color(
    spine_slot_pose self,
    bool hasDarkColor,
  ) {
    return _spine_slot_pose_set_has_dark_color(
      self,
      hasDarkColor,
    );
  }

  late final _spine_slot_pose_set_has_dark_colorPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_pose, ffi.Bool)>>(
          'spine_slot_pose_set_has_dark_color');
  late final _spine_slot_pose_set_has_dark_color =
      _spine_slot_pose_set_has_dark_colorPtr
          .asFunction<void Function(spine_slot_pose, bool)>();

  spine_attachment spine_slot_pose_get_attachment(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_get_attachment(
      self,
    );
  }

  late final _spine_slot_pose_get_attachmentPtr =
      _lookup<ffi.NativeFunction<spine_attachment Function(spine_slot_pose)>>(
          'spine_slot_pose_get_attachment');
  late final _spine_slot_pose_get_attachment =
      _spine_slot_pose_get_attachmentPtr
          .asFunction<spine_attachment Function(spine_slot_pose)>();

  void spine_slot_pose_set_attachment(
    spine_slot_pose self,
    spine_attachment attachment,
  ) {
    return _spine_slot_pose_set_attachment(
      self,
      attachment,
    );
  }

  late final _spine_slot_pose_set_attachmentPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_slot_pose,
              spine_attachment)>>('spine_slot_pose_set_attachment');
  late final _spine_slot_pose_set_attachment =
      _spine_slot_pose_set_attachmentPtr
          .asFunction<void Function(spine_slot_pose, spine_attachment)>();

  int spine_slot_pose_get_sequence_index(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_get_sequence_index(
      self,
    );
  }

  late final _spine_slot_pose_get_sequence_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_slot_pose)>>(
          'spine_slot_pose_get_sequence_index');
  late final _spine_slot_pose_get_sequence_index =
      _spine_slot_pose_get_sequence_indexPtr
          .asFunction<int Function(spine_slot_pose)>();

  void spine_slot_pose_set_sequence_index(
    spine_slot_pose self,
    int sequenceIndex,
  ) {
    return _spine_slot_pose_set_sequence_index(
      self,
      sequenceIndex,
    );
  }

  late final _spine_slot_pose_set_sequence_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_pose, ffi.Int)>>(
          'spine_slot_pose_set_sequence_index');
  late final _spine_slot_pose_set_sequence_index =
      _spine_slot_pose_set_sequence_indexPtr
          .asFunction<void Function(spine_slot_pose, int)>();

  spine_array_float spine_slot_pose_get_deform(
    spine_slot_pose self,
  ) {
    return _spine_slot_pose_get_deform(
      self,
    );
  }

  late final _spine_slot_pose_get_deformPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_slot_pose)>>(
          'spine_slot_pose_get_deform');
  late final _spine_slot_pose_get_deform = _spine_slot_pose_get_deformPtr
      .asFunction<spine_array_float Function(spine_slot_pose)>();

  void spine_slot_timeline_dispose(
    spine_slot_timeline self,
  ) {
    return _spine_slot_timeline_dispose(
      self,
    );
  }

  late final _spine_slot_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_timeline)>>(
          'spine_slot_timeline_dispose');
  late final _spine_slot_timeline_dispose = _spine_slot_timeline_disposePtr
      .asFunction<void Function(spine_slot_timeline)>();

  spine_rtti spine_slot_timeline_get_rtti(
    spine_slot_timeline self,
  ) {
    return _spine_slot_timeline_get_rtti(
      self,
    );
  }

  late final _spine_slot_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_slot_timeline)>>(
          'spine_slot_timeline_get_rtti');
  late final _spine_slot_timeline_get_rtti = _spine_slot_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_slot_timeline)>();

  int spine_slot_timeline_get_slot_index(
    spine_slot_timeline self,
  ) {
    return _spine_slot_timeline_get_slot_index(
      self,
    );
  }

  late final _spine_slot_timeline_get_slot_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_slot_timeline)>>(
          'spine_slot_timeline_get_slot_index');
  late final _spine_slot_timeline_get_slot_index =
      _spine_slot_timeline_get_slot_indexPtr
          .asFunction<int Function(spine_slot_timeline)>();

  void spine_slot_timeline_set_slot_index(
    spine_slot_timeline self,
    int inValue,
  ) {
    return _spine_slot_timeline_set_slot_index(
      self,
      inValue,
    );
  }

  late final _spine_slot_timeline_set_slot_indexPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_slot_timeline, ffi.Int)>>(
      'spine_slot_timeline_set_slot_index');
  late final _spine_slot_timeline_set_slot_index =
      _spine_slot_timeline_set_slot_indexPtr
          .asFunction<void Function(spine_slot_timeline, int)>();

  spine_rtti spine_slot_timeline_rtti() {
    return _spine_slot_timeline_rtti();
  }

  late final _spine_slot_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_slot_timeline_rtti');
  late final _spine_slot_timeline_rtti =
      _spine_slot_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_texture_region spine_texture_region_create() {
    return _spine_texture_region_create();
  }

  late final _spine_texture_region_createPtr =
      _lookup<ffi.NativeFunction<spine_texture_region Function()>>(
          'spine_texture_region_create');
  late final _spine_texture_region_create = _spine_texture_region_createPtr
      .asFunction<spine_texture_region Function()>();

  void spine_texture_region_dispose(
    spine_texture_region self,
  ) {
    return _spine_texture_region_dispose(
      self,
    );
  }

  late final _spine_texture_region_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region)>>(
          'spine_texture_region_dispose');
  late final _spine_texture_region_dispose = _spine_texture_region_disposePtr
      .asFunction<void Function(spine_texture_region)>();

  spine_rtti spine_texture_region_get_rtti(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_rtti(
      self,
    );
  }

  late final _spine_texture_region_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_texture_region)>>(
          'spine_texture_region_get_rtti');
  late final _spine_texture_region_get_rtti = _spine_texture_region_get_rttiPtr
      .asFunction<spine_rtti Function(spine_texture_region)>();

  double spine_texture_region_get_u(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_u(
      self,
    );
  }

  late final _spine_texture_region_get_uPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>(
          'spine_texture_region_get_u');
  late final _spine_texture_region_get_u = _spine_texture_region_get_uPtr
      .asFunction<double Function(spine_texture_region)>();

  void spine_texture_region_set_u(
    spine_texture_region self,
    double value,
  ) {
    return _spine_texture_region_set_u(
      self,
      value,
    );
  }

  late final _spine_texture_region_set_uPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>(
      'spine_texture_region_set_u');
  late final _spine_texture_region_set_u = _spine_texture_region_set_uPtr
      .asFunction<void Function(spine_texture_region, double)>();

  double spine_texture_region_get_v(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_v(
      self,
    );
  }

  late final _spine_texture_region_get_vPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>(
          'spine_texture_region_get_v');
  late final _spine_texture_region_get_v = _spine_texture_region_get_vPtr
      .asFunction<double Function(spine_texture_region)>();

  void spine_texture_region_set_v(
    spine_texture_region self,
    double value,
  ) {
    return _spine_texture_region_set_v(
      self,
      value,
    );
  }

  late final _spine_texture_region_set_vPtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>(
      'spine_texture_region_set_v');
  late final _spine_texture_region_set_v = _spine_texture_region_set_vPtr
      .asFunction<void Function(spine_texture_region, double)>();

  double spine_texture_region_get_u2(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_u2(
      self,
    );
  }

  late final _spine_texture_region_get_u2Ptr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>(
          'spine_texture_region_get_u2');
  late final _spine_texture_region_get_u2 = _spine_texture_region_get_u2Ptr
      .asFunction<double Function(spine_texture_region)>();

  void spine_texture_region_set_u2(
    spine_texture_region self,
    double value,
  ) {
    return _spine_texture_region_set_u2(
      self,
      value,
    );
  }

  late final _spine_texture_region_set_u2Ptr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>(
      'spine_texture_region_set_u2');
  late final _spine_texture_region_set_u2 = _spine_texture_region_set_u2Ptr
      .asFunction<void Function(spine_texture_region, double)>();

  double spine_texture_region_get_v2(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_v2(
      self,
    );
  }

  late final _spine_texture_region_get_v2Ptr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>(
          'spine_texture_region_get_v2');
  late final _spine_texture_region_get_v2 = _spine_texture_region_get_v2Ptr
      .asFunction<double Function(spine_texture_region)>();

  void spine_texture_region_set_v2(
    spine_texture_region self,
    double value,
  ) {
    return _spine_texture_region_set_v2(
      self,
      value,
    );
  }

  late final _spine_texture_region_set_v2Ptr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>(
      'spine_texture_region_set_v2');
  late final _spine_texture_region_set_v2 = _spine_texture_region_set_v2Ptr
      .asFunction<void Function(spine_texture_region, double)>();

  int spine_texture_region_get_region_width(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_region_width(
      self,
    );
  }

  late final _spine_texture_region_get_region_widthPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_texture_region)>>(
          'spine_texture_region_get_region_width');
  late final _spine_texture_region_get_region_width =
      _spine_texture_region_get_region_widthPtr
          .asFunction<int Function(spine_texture_region)>();

  void spine_texture_region_set_region_width(
    spine_texture_region self,
    int value,
  ) {
    return _spine_texture_region_set_region_width(
      self,
      value,
    );
  }

  late final _spine_texture_region_set_region_widthPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int)>>(
      'spine_texture_region_set_region_width');
  late final _spine_texture_region_set_region_width =
      _spine_texture_region_set_region_widthPtr
          .asFunction<void Function(spine_texture_region, int)>();

  int spine_texture_region_get_region_height(
    spine_texture_region self,
  ) {
    return _spine_texture_region_get_region_height(
      self,
    );
  }

  late final _spine_texture_region_get_region_heightPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_texture_region)>>(
          'spine_texture_region_get_region_height');
  late final _spine_texture_region_get_region_height =
      _spine_texture_region_get_region_heightPtr
          .asFunction<int Function(spine_texture_region)>();

  void spine_texture_region_set_region_height(
    spine_texture_region self,
    int value,
  ) {
    return _spine_texture_region_set_region_height(
      self,
      value,
    );
  }

  late final _spine_texture_region_set_region_heightPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int)>>(
      'spine_texture_region_set_region_height');
  late final _spine_texture_region_set_region_height =
      _spine_texture_region_set_region_heightPtr
          .asFunction<void Function(spine_texture_region, int)>();

  spine_rtti spine_texture_region_rtti() {
    return _spine_texture_region_rtti();
  }

  late final _spine_texture_region_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_texture_region_rtti');
  late final _spine_texture_region_rtti =
      _spine_texture_region_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_timeline_dispose(
    spine_timeline self,
  ) {
    return _spine_timeline_dispose(
      self,
    );
  }

  late final _spine_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_timeline)>>(
          'spine_timeline_dispose');
  late final _spine_timeline_dispose =
      _spine_timeline_disposePtr.asFunction<void Function(spine_timeline)>();

  spine_rtti spine_timeline_get_rtti(
    spine_timeline self,
  ) {
    return _spine_timeline_get_rtti(
      self,
    );
  }

  late final _spine_timeline_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_timeline)>>(
          'spine_timeline_get_rtti');
  late final _spine_timeline_get_rtti = _spine_timeline_get_rttiPtr
      .asFunction<spine_rtti Function(spine_timeline)>();

  void spine_timeline_apply(
    spine_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_timeline_apply');
  late final _spine_timeline_apply = _spine_timeline_applyPtr.asFunction<
      void Function(spine_timeline, spine_skeleton, double, double,
          spine_array_event, double, int, int, bool)>();

  int spine_timeline_get_frame_entries(
    spine_timeline self,
  ) {
    return _spine_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_timeline)>>(
          'spine_timeline_get_frame_entries');
  late final _spine_timeline_get_frame_entries =
      _spine_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_timeline)>();

  int spine_timeline_get_frame_count(
    spine_timeline self,
  ) {
    return _spine_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_timeline)>>(
          'spine_timeline_get_frame_count');
  late final _spine_timeline_get_frame_count =
      _spine_timeline_get_frame_countPtr
          .asFunction<int Function(spine_timeline)>();

  spine_array_float spine_timeline_get_frames(
    spine_timeline self,
  ) {
    return _spine_timeline_get_frames(
      self,
    );
  }

  late final _spine_timeline_get_framesPtr =
      _lookup<ffi.NativeFunction<spine_array_float Function(spine_timeline)>>(
          'spine_timeline_get_frames');
  late final _spine_timeline_get_frames = _spine_timeline_get_framesPtr
      .asFunction<spine_array_float Function(spine_timeline)>();

  double spine_timeline_get_duration(
    spine_timeline self,
  ) {
    return _spine_timeline_get_duration(
      self,
    );
  }

  late final _spine_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_timeline)>>(
          'spine_timeline_get_duration');
  late final _spine_timeline_get_duration = _spine_timeline_get_durationPtr
      .asFunction<double Function(spine_timeline)>();

  spine_array_property_id spine_timeline_get_property_ids(
    spine_timeline self,
  ) {
    return _spine_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<spine_array_property_id Function(spine_timeline)>>(
      'spine_timeline_get_property_ids');
  late final _spine_timeline_get_property_ids =
      _spine_timeline_get_property_idsPtr
          .asFunction<spine_array_property_id Function(spine_timeline)>();

  spine_rtti spine_timeline_rtti() {
    return _spine_timeline_rtti();
  }

  late final _spine_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_timeline_rtti');
  late final _spine_timeline_rtti =
      _spine_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_to_property_dispose(
    spine_to_property self,
  ) {
    return _spine_to_property_dispose(
      self,
    );
  }

  late final _spine_to_property_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_property)>>(
          'spine_to_property_dispose');
  late final _spine_to_property_dispose = _spine_to_property_disposePtr
      .asFunction<void Function(spine_to_property)>();

  spine_rtti spine_to_property_get_rtti(
    spine_to_property self,
  ) {
    return _spine_to_property_get_rtti(
      self,
    );
  }

  late final _spine_to_property_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_property)>>(
          'spine_to_property_get_rtti');
  late final _spine_to_property_get_rtti = _spine_to_property_get_rttiPtr
      .asFunction<spine_rtti Function(spine_to_property)>();

  double spine_to_property_mix(
    spine_to_property self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_property_mix(
      self,
      pose,
    );
  }

  late final _spine_to_property_mixPtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_to_property,
              spine_transform_constraint_pose)>>('spine_to_property_mix');
  late final _spine_to_property_mix = _spine_to_property_mixPtr.asFunction<
      double Function(spine_to_property, spine_transform_constraint_pose)>();

  void spine_to_property_apply(
    spine_to_property self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_property_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_property_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_to_property,
              spine_skeleton,
              spine_transform_constraint_pose,
              spine_bone_pose,
              ffi.Float,
              ffi.Bool,
              ffi.Bool)>>('spine_to_property_apply');
  late final _spine_to_property_apply = _spine_to_property_applyPtr.asFunction<
      void Function(
          spine_to_property,
          spine_skeleton,
          spine_transform_constraint_pose,
          spine_bone_pose,
          double,
          bool,
          bool)>();

  spine_rtti spine_to_property_rtti() {
    return _spine_to_property_rtti();
  }

  late final _spine_to_property_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_to_property_rtti');
  late final _spine_to_property_rtti =
      _spine_to_property_rttiPtr.asFunction<spine_rtti Function()>();

  double spine_to_property_get__offset(
    spine_to_property self,
  ) {
    return _spine_to_property_get__offset(
      self,
    );
  }

  late final _spine_to_property_get__offsetPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_to_property)>>(
          'spine_to_property_get__offset');
  late final _spine_to_property_get__offset = _spine_to_property_get__offsetPtr
      .asFunction<double Function(spine_to_property)>();

  void spine_to_property_set__offset(
    spine_to_property self,
    double value,
  ) {
    return _spine_to_property_set__offset(
      self,
      value,
    );
  }

  late final _spine_to_property_set__offsetPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_to_property, ffi.Float)>>(
      'spine_to_property_set__offset');
  late final _spine_to_property_set__offset = _spine_to_property_set__offsetPtr
      .asFunction<void Function(spine_to_property, double)>();

  double spine_to_property_get__max(
    spine_to_property self,
  ) {
    return _spine_to_property_get__max(
      self,
    );
  }

  late final _spine_to_property_get__maxPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_to_property)>>(
          'spine_to_property_get__max');
  late final _spine_to_property_get__max = _spine_to_property_get__maxPtr
      .asFunction<double Function(spine_to_property)>();

  void spine_to_property_set__max(
    spine_to_property self,
    double value,
  ) {
    return _spine_to_property_set__max(
      self,
      value,
    );
  }

  late final _spine_to_property_set__maxPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_to_property, ffi.Float)>>(
      'spine_to_property_set__max');
  late final _spine_to_property_set__max = _spine_to_property_set__maxPtr
      .asFunction<void Function(spine_to_property, double)>();

  double spine_to_property_get__scale(
    spine_to_property self,
  ) {
    return _spine_to_property_get__scale(
      self,
    );
  }

  late final _spine_to_property_get__scalePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_to_property)>>(
          'spine_to_property_get__scale');
  late final _spine_to_property_get__scale = _spine_to_property_get__scalePtr
      .asFunction<double Function(spine_to_property)>();

  void spine_to_property_set__scale(
    spine_to_property self,
    double value,
  ) {
    return _spine_to_property_set__scale(
      self,
      value,
    );
  }

  late final _spine_to_property_set__scalePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_to_property, ffi.Float)>>(
      'spine_to_property_set__scale');
  late final _spine_to_property_set__scale = _spine_to_property_set__scalePtr
      .asFunction<void Function(spine_to_property, double)>();

  spine_to_rotate spine_to_rotate_create() {
    return _spine_to_rotate_create();
  }

  late final _spine_to_rotate_createPtr =
      _lookup<ffi.NativeFunction<spine_to_rotate Function()>>(
          'spine_to_rotate_create');
  late final _spine_to_rotate_create =
      _spine_to_rotate_createPtr.asFunction<spine_to_rotate Function()>();

  void spine_to_rotate_dispose(
    spine_to_rotate self,
  ) {
    return _spine_to_rotate_dispose(
      self,
    );
  }

  late final _spine_to_rotate_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_rotate)>>(
          'spine_to_rotate_dispose');
  late final _spine_to_rotate_dispose =
      _spine_to_rotate_disposePtr.asFunction<void Function(spine_to_rotate)>();

  spine_rtti spine_to_rotate_get_rtti(
    spine_to_rotate self,
  ) {
    return _spine_to_rotate_get_rtti(
      self,
    );
  }

  late final _spine_to_rotate_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_rotate)>>(
          'spine_to_rotate_get_rtti');
  late final _spine_to_rotate_get_rtti = _spine_to_rotate_get_rttiPtr
      .asFunction<spine_rtti Function(spine_to_rotate)>();

  double spine_to_rotate_mix(
    spine_to_rotate self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_rotate_mix(
      self,
      pose,
    );
  }

  late final _spine_to_rotate_mixPtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_to_rotate,
              spine_transform_constraint_pose)>>('spine_to_rotate_mix');
  late final _spine_to_rotate_mix = _spine_to_rotate_mixPtr.asFunction<
      double Function(spine_to_rotate, spine_transform_constraint_pose)>();

  void spine_to_rotate_apply(
    spine_to_rotate self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_rotate_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_rotate_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_to_rotate,
              spine_skeleton,
              spine_transform_constraint_pose,
              spine_bone_pose,
              ffi.Float,
              ffi.Bool,
              ffi.Bool)>>('spine_to_rotate_apply');
  late final _spine_to_rotate_apply = _spine_to_rotate_applyPtr.asFunction<
      void Function(
          spine_to_rotate,
          spine_skeleton,
          spine_transform_constraint_pose,
          spine_bone_pose,
          double,
          bool,
          bool)>();

  spine_rtti spine_to_rotate_rtti() {
    return _spine_to_rotate_rtti();
  }

  late final _spine_to_rotate_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_to_rotate_rtti');
  late final _spine_to_rotate_rtti =
      _spine_to_rotate_rttiPtr.asFunction<spine_rtti Function()>();

  spine_to_scale_x spine_to_scale_x_create() {
    return _spine_to_scale_x_create();
  }

  late final _spine_to_scale_x_createPtr =
      _lookup<ffi.NativeFunction<spine_to_scale_x Function()>>(
          'spine_to_scale_x_create');
  late final _spine_to_scale_x_create =
      _spine_to_scale_x_createPtr.asFunction<spine_to_scale_x Function()>();

  void spine_to_scale_x_dispose(
    spine_to_scale_x self,
  ) {
    return _spine_to_scale_x_dispose(
      self,
    );
  }

  late final _spine_to_scale_x_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_scale_x)>>(
          'spine_to_scale_x_dispose');
  late final _spine_to_scale_x_dispose = _spine_to_scale_x_disposePtr
      .asFunction<void Function(spine_to_scale_x)>();

  spine_rtti spine_to_scale_x_get_rtti(
    spine_to_scale_x self,
  ) {
    return _spine_to_scale_x_get_rtti(
      self,
    );
  }

  late final _spine_to_scale_x_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_scale_x)>>(
          'spine_to_scale_x_get_rtti');
  late final _spine_to_scale_x_get_rtti = _spine_to_scale_x_get_rttiPtr
      .asFunction<spine_rtti Function(spine_to_scale_x)>();

  double spine_to_scale_x_mix(
    spine_to_scale_x self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_scale_x_mix(
      self,
      pose,
    );
  }

  late final _spine_to_scale_x_mixPtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_to_scale_x,
              spine_transform_constraint_pose)>>('spine_to_scale_x_mix');
  late final _spine_to_scale_x_mix = _spine_to_scale_x_mixPtr.asFunction<
      double Function(spine_to_scale_x, spine_transform_constraint_pose)>();

  void spine_to_scale_x_apply(
    spine_to_scale_x self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_scale_x_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_scale_x_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_to_scale_x,
              spine_skeleton,
              spine_transform_constraint_pose,
              spine_bone_pose,
              ffi.Float,
              ffi.Bool,
              ffi.Bool)>>('spine_to_scale_x_apply');
  late final _spine_to_scale_x_apply = _spine_to_scale_x_applyPtr.asFunction<
      void Function(
          spine_to_scale_x,
          spine_skeleton,
          spine_transform_constraint_pose,
          spine_bone_pose,
          double,
          bool,
          bool)>();

  spine_rtti spine_to_scale_x_rtti() {
    return _spine_to_scale_x_rtti();
  }

  late final _spine_to_scale_x_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_to_scale_x_rtti');
  late final _spine_to_scale_x_rtti =
      _spine_to_scale_x_rttiPtr.asFunction<spine_rtti Function()>();

  spine_to_scale_y spine_to_scale_y_create() {
    return _spine_to_scale_y_create();
  }

  late final _spine_to_scale_y_createPtr =
      _lookup<ffi.NativeFunction<spine_to_scale_y Function()>>(
          'spine_to_scale_y_create');
  late final _spine_to_scale_y_create =
      _spine_to_scale_y_createPtr.asFunction<spine_to_scale_y Function()>();

  void spine_to_scale_y_dispose(
    spine_to_scale_y self,
  ) {
    return _spine_to_scale_y_dispose(
      self,
    );
  }

  late final _spine_to_scale_y_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_scale_y)>>(
          'spine_to_scale_y_dispose');
  late final _spine_to_scale_y_dispose = _spine_to_scale_y_disposePtr
      .asFunction<void Function(spine_to_scale_y)>();

  spine_rtti spine_to_scale_y_get_rtti(
    spine_to_scale_y self,
  ) {
    return _spine_to_scale_y_get_rtti(
      self,
    );
  }

  late final _spine_to_scale_y_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_scale_y)>>(
          'spine_to_scale_y_get_rtti');
  late final _spine_to_scale_y_get_rtti = _spine_to_scale_y_get_rttiPtr
      .asFunction<spine_rtti Function(spine_to_scale_y)>();

  double spine_to_scale_y_mix(
    spine_to_scale_y self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_scale_y_mix(
      self,
      pose,
    );
  }

  late final _spine_to_scale_y_mixPtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_to_scale_y,
              spine_transform_constraint_pose)>>('spine_to_scale_y_mix');
  late final _spine_to_scale_y_mix = _spine_to_scale_y_mixPtr.asFunction<
      double Function(spine_to_scale_y, spine_transform_constraint_pose)>();

  void spine_to_scale_y_apply(
    spine_to_scale_y self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_scale_y_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_scale_y_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_to_scale_y,
              spine_skeleton,
              spine_transform_constraint_pose,
              spine_bone_pose,
              ffi.Float,
              ffi.Bool,
              ffi.Bool)>>('spine_to_scale_y_apply');
  late final _spine_to_scale_y_apply = _spine_to_scale_y_applyPtr.asFunction<
      void Function(
          spine_to_scale_y,
          spine_skeleton,
          spine_transform_constraint_pose,
          spine_bone_pose,
          double,
          bool,
          bool)>();

  spine_rtti spine_to_scale_y_rtti() {
    return _spine_to_scale_y_rtti();
  }

  late final _spine_to_scale_y_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_to_scale_y_rtti');
  late final _spine_to_scale_y_rtti =
      _spine_to_scale_y_rttiPtr.asFunction<spine_rtti Function()>();

  spine_to_shear_y spine_to_shear_y_create() {
    return _spine_to_shear_y_create();
  }

  late final _spine_to_shear_y_createPtr =
      _lookup<ffi.NativeFunction<spine_to_shear_y Function()>>(
          'spine_to_shear_y_create');
  late final _spine_to_shear_y_create =
      _spine_to_shear_y_createPtr.asFunction<spine_to_shear_y Function()>();

  void spine_to_shear_y_dispose(
    spine_to_shear_y self,
  ) {
    return _spine_to_shear_y_dispose(
      self,
    );
  }

  late final _spine_to_shear_y_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_shear_y)>>(
          'spine_to_shear_y_dispose');
  late final _spine_to_shear_y_dispose = _spine_to_shear_y_disposePtr
      .asFunction<void Function(spine_to_shear_y)>();

  spine_rtti spine_to_shear_y_get_rtti(
    spine_to_shear_y self,
  ) {
    return _spine_to_shear_y_get_rtti(
      self,
    );
  }

  late final _spine_to_shear_y_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_shear_y)>>(
          'spine_to_shear_y_get_rtti');
  late final _spine_to_shear_y_get_rtti = _spine_to_shear_y_get_rttiPtr
      .asFunction<spine_rtti Function(spine_to_shear_y)>();

  double spine_to_shear_y_mix(
    spine_to_shear_y self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_shear_y_mix(
      self,
      pose,
    );
  }

  late final _spine_to_shear_y_mixPtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_to_shear_y,
              spine_transform_constraint_pose)>>('spine_to_shear_y_mix');
  late final _spine_to_shear_y_mix = _spine_to_shear_y_mixPtr.asFunction<
      double Function(spine_to_shear_y, spine_transform_constraint_pose)>();

  void spine_to_shear_y_apply(
    spine_to_shear_y self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_shear_y_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_shear_y_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_to_shear_y,
              spine_skeleton,
              spine_transform_constraint_pose,
              spine_bone_pose,
              ffi.Float,
              ffi.Bool,
              ffi.Bool)>>('spine_to_shear_y_apply');
  late final _spine_to_shear_y_apply = _spine_to_shear_y_applyPtr.asFunction<
      void Function(
          spine_to_shear_y,
          spine_skeleton,
          spine_transform_constraint_pose,
          spine_bone_pose,
          double,
          bool,
          bool)>();

  spine_rtti spine_to_shear_y_rtti() {
    return _spine_to_shear_y_rtti();
  }

  late final _spine_to_shear_y_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_to_shear_y_rtti');
  late final _spine_to_shear_y_rtti =
      _spine_to_shear_y_rttiPtr.asFunction<spine_rtti Function()>();

  spine_to_x spine_to_x_create() {
    return _spine_to_x_create();
  }

  late final _spine_to_x_createPtr =
      _lookup<ffi.NativeFunction<spine_to_x Function()>>('spine_to_x_create');
  late final _spine_to_x_create =
      _spine_to_x_createPtr.asFunction<spine_to_x Function()>();

  void spine_to_x_dispose(
    spine_to_x self,
  ) {
    return _spine_to_x_dispose(
      self,
    );
  }

  late final _spine_to_x_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_x)>>(
          'spine_to_x_dispose');
  late final _spine_to_x_dispose =
      _spine_to_x_disposePtr.asFunction<void Function(spine_to_x)>();

  spine_rtti spine_to_x_get_rtti(
    spine_to_x self,
  ) {
    return _spine_to_x_get_rtti(
      self,
    );
  }

  late final _spine_to_x_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_x)>>(
          'spine_to_x_get_rtti');
  late final _spine_to_x_get_rtti =
      _spine_to_x_get_rttiPtr.asFunction<spine_rtti Function(spine_to_x)>();

  double spine_to_x_mix(
    spine_to_x self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_x_mix(
      self,
      pose,
    );
  }

  late final _spine_to_x_mixPtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_to_x, spine_transform_constraint_pose)>>('spine_to_x_mix');
  late final _spine_to_x_mix = _spine_to_x_mixPtr.asFunction<
      double Function(spine_to_x, spine_transform_constraint_pose)>();

  void spine_to_x_apply(
    spine_to_x self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_x_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_x_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_to_x,
              spine_skeleton,
              spine_transform_constraint_pose,
              spine_bone_pose,
              ffi.Float,
              ffi.Bool,
              ffi.Bool)>>('spine_to_x_apply');
  late final _spine_to_x_apply = _spine_to_x_applyPtr.asFunction<
      void Function(spine_to_x, spine_skeleton, spine_transform_constraint_pose,
          spine_bone_pose, double, bool, bool)>();

  spine_rtti spine_to_x_rtti() {
    return _spine_to_x_rtti();
  }

  late final _spine_to_x_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_to_x_rtti');
  late final _spine_to_x_rtti =
      _spine_to_x_rttiPtr.asFunction<spine_rtti Function()>();

  spine_to_y spine_to_y_create() {
    return _spine_to_y_create();
  }

  late final _spine_to_y_createPtr =
      _lookup<ffi.NativeFunction<spine_to_y Function()>>('spine_to_y_create');
  late final _spine_to_y_create =
      _spine_to_y_createPtr.asFunction<spine_to_y Function()>();

  void spine_to_y_dispose(
    spine_to_y self,
  ) {
    return _spine_to_y_dispose(
      self,
    );
  }

  late final _spine_to_y_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_to_y)>>(
          'spine_to_y_dispose');
  late final _spine_to_y_dispose =
      _spine_to_y_disposePtr.asFunction<void Function(spine_to_y)>();

  spine_rtti spine_to_y_get_rtti(
    spine_to_y self,
  ) {
    return _spine_to_y_get_rtti(
      self,
    );
  }

  late final _spine_to_y_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_to_y)>>(
          'spine_to_y_get_rtti');
  late final _spine_to_y_get_rtti =
      _spine_to_y_get_rttiPtr.asFunction<spine_rtti Function(spine_to_y)>();

  double spine_to_y_mix(
    spine_to_y self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_to_y_mix(
      self,
      pose,
    );
  }

  late final _spine_to_y_mixPtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_to_y, spine_transform_constraint_pose)>>('spine_to_y_mix');
  late final _spine_to_y_mix = _spine_to_y_mixPtr.asFunction<
      double Function(spine_to_y, spine_transform_constraint_pose)>();

  void spine_to_y_apply(
    spine_to_y self,
    spine_skeleton skeleton,
    spine_transform_constraint_pose pose,
    spine_bone_pose bone,
    double value,
    bool local,
    bool additive,
  ) {
    return _spine_to_y_apply(
      self,
      skeleton,
      pose,
      bone,
      value,
      local,
      additive,
    );
  }

  late final _spine_to_y_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_to_y,
              spine_skeleton,
              spine_transform_constraint_pose,
              spine_bone_pose,
              ffi.Float,
              ffi.Bool,
              ffi.Bool)>>('spine_to_y_apply');
  late final _spine_to_y_apply = _spine_to_y_applyPtr.asFunction<
      void Function(spine_to_y, spine_skeleton, spine_transform_constraint_pose,
          spine_bone_pose, double, bool, bool)>();

  spine_rtti spine_to_y_rtti() {
    return _spine_to_y_rtti();
  }

  late final _spine_to_y_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_to_y_rtti');
  late final _spine_to_y_rtti =
      _spine_to_y_rttiPtr.asFunction<spine_rtti Function()>();

  spine_track_entry spine_track_entry_create() {
    return _spine_track_entry_create();
  }

  late final _spine_track_entry_createPtr =
      _lookup<ffi.NativeFunction<spine_track_entry Function()>>(
          'spine_track_entry_create');
  late final _spine_track_entry_create =
      _spine_track_entry_createPtr.asFunction<spine_track_entry Function()>();

  void spine_track_entry_dispose(
    spine_track_entry self,
  ) {
    return _spine_track_entry_dispose(
      self,
    );
  }

  late final _spine_track_entry_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry)>>(
          'spine_track_entry_dispose');
  late final _spine_track_entry_dispose = _spine_track_entry_disposePtr
      .asFunction<void Function(spine_track_entry)>();

  int spine_track_entry_get_track_index(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_track_index(
      self,
    );
  }

  late final _spine_track_entry_get_track_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_track_entry)>>(
          'spine_track_entry_get_track_index');
  late final _spine_track_entry_get_track_index =
      _spine_track_entry_get_track_indexPtr
          .asFunction<int Function(spine_track_entry)>();

  spine_animation spine_track_entry_get_animation(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_animation(
      self,
    );
  }

  late final _spine_track_entry_get_animationPtr =
      _lookup<ffi.NativeFunction<spine_animation Function(spine_track_entry)>>(
          'spine_track_entry_get_animation');
  late final _spine_track_entry_get_animation =
      _spine_track_entry_get_animationPtr
          .asFunction<spine_animation Function(spine_track_entry)>();

  void spine_track_entry_set_animation(
    spine_track_entry self,
    spine_animation animation,
  ) {
    return _spine_track_entry_set_animation(
      self,
      animation,
    );
  }

  late final _spine_track_entry_set_animationPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_track_entry,
              spine_animation)>>('spine_track_entry_set_animation');
  late final _spine_track_entry_set_animation =
      _spine_track_entry_set_animationPtr
          .asFunction<void Function(spine_track_entry, spine_animation)>();

  spine_track_entry spine_track_entry_get_previous(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_previous(
      self,
    );
  }

  late final _spine_track_entry_get_previousPtr = _lookup<
          ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>(
      'spine_track_entry_get_previous');
  late final _spine_track_entry_get_previous =
      _spine_track_entry_get_previousPtr
          .asFunction<spine_track_entry Function(spine_track_entry)>();

  bool spine_track_entry_get_loop(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_loop(
      self,
    );
  }

  late final _spine_track_entry_get_loopPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>(
          'spine_track_entry_get_loop');
  late final _spine_track_entry_get_loop = _spine_track_entry_get_loopPtr
      .asFunction<bool Function(spine_track_entry)>();

  void spine_track_entry_set_loop(
    spine_track_entry self,
    bool inValue,
  ) {
    return _spine_track_entry_set_loop(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_loopPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Bool)>>(
      'spine_track_entry_set_loop');
  late final _spine_track_entry_set_loop = _spine_track_entry_set_loopPtr
      .asFunction<void Function(spine_track_entry, bool)>();

  bool spine_track_entry_get_hold_previous(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_hold_previous(
      self,
    );
  }

  late final _spine_track_entry_get_hold_previousPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>(
          'spine_track_entry_get_hold_previous');
  late final _spine_track_entry_get_hold_previous =
      _spine_track_entry_get_hold_previousPtr
          .asFunction<bool Function(spine_track_entry)>();

  void spine_track_entry_set_hold_previous(
    spine_track_entry self,
    bool inValue,
  ) {
    return _spine_track_entry_set_hold_previous(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_hold_previousPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Bool)>>(
      'spine_track_entry_set_hold_previous');
  late final _spine_track_entry_set_hold_previous =
      _spine_track_entry_set_hold_previousPtr
          .asFunction<void Function(spine_track_entry, bool)>();

  bool spine_track_entry_get_reverse(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_reverse(
      self,
    );
  }

  late final _spine_track_entry_get_reversePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>(
          'spine_track_entry_get_reverse');
  late final _spine_track_entry_get_reverse = _spine_track_entry_get_reversePtr
      .asFunction<bool Function(spine_track_entry)>();

  void spine_track_entry_set_reverse(
    spine_track_entry self,
    bool inValue,
  ) {
    return _spine_track_entry_set_reverse(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_reversePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Bool)>>(
      'spine_track_entry_set_reverse');
  late final _spine_track_entry_set_reverse = _spine_track_entry_set_reversePtr
      .asFunction<void Function(spine_track_entry, bool)>();

  bool spine_track_entry_get_shortest_rotation(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_shortest_rotation(
      self,
    );
  }

  late final _spine_track_entry_get_shortest_rotationPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>(
          'spine_track_entry_get_shortest_rotation');
  late final _spine_track_entry_get_shortest_rotation =
      _spine_track_entry_get_shortest_rotationPtr
          .asFunction<bool Function(spine_track_entry)>();

  void spine_track_entry_set_shortest_rotation(
    spine_track_entry self,
    bool inValue,
  ) {
    return _spine_track_entry_set_shortest_rotation(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_shortest_rotationPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Bool)>>(
      'spine_track_entry_set_shortest_rotation');
  late final _spine_track_entry_set_shortest_rotation =
      _spine_track_entry_set_shortest_rotationPtr
          .asFunction<void Function(spine_track_entry, bool)>();

  double spine_track_entry_get_delay(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_delay(
      self,
    );
  }

  late final _spine_track_entry_get_delayPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_delay');
  late final _spine_track_entry_get_delay = _spine_track_entry_get_delayPtr
      .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_delay(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_delay(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_delayPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_delay');
  late final _spine_track_entry_set_delay = _spine_track_entry_set_delayPtr
      .asFunction<void Function(spine_track_entry, double)>();

  double spine_track_entry_get_track_time(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_track_time(
      self,
    );
  }

  late final _spine_track_entry_get_track_timePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_track_time');
  late final _spine_track_entry_get_track_time =
      _spine_track_entry_get_track_timePtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_track_time(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_track_time(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_track_timePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_track_time');
  late final _spine_track_entry_set_track_time =
      _spine_track_entry_set_track_timePtr
          .asFunction<void Function(spine_track_entry, double)>();

  double spine_track_entry_get_track_end(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_track_end(
      self,
    );
  }

  late final _spine_track_entry_get_track_endPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_track_end');
  late final _spine_track_entry_get_track_end =
      _spine_track_entry_get_track_endPtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_track_end(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_track_end(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_track_endPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_track_end');
  late final _spine_track_entry_set_track_end =
      _spine_track_entry_set_track_endPtr
          .asFunction<void Function(spine_track_entry, double)>();

  double spine_track_entry_get_animation_start(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_animation_start(
      self,
    );
  }

  late final _spine_track_entry_get_animation_startPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_animation_start');
  late final _spine_track_entry_get_animation_start =
      _spine_track_entry_get_animation_startPtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_animation_start(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_animation_start(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_animation_startPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_animation_start');
  late final _spine_track_entry_set_animation_start =
      _spine_track_entry_set_animation_startPtr
          .asFunction<void Function(spine_track_entry, double)>();

  double spine_track_entry_get_animation_end(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_animation_end(
      self,
    );
  }

  late final _spine_track_entry_get_animation_endPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_animation_end');
  late final _spine_track_entry_get_animation_end =
      _spine_track_entry_get_animation_endPtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_animation_end(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_animation_end(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_animation_endPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_animation_end');
  late final _spine_track_entry_set_animation_end =
      _spine_track_entry_set_animation_endPtr
          .asFunction<void Function(spine_track_entry, double)>();

  double spine_track_entry_get_animation_last(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_animation_last(
      self,
    );
  }

  late final _spine_track_entry_get_animation_lastPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_animation_last');
  late final _spine_track_entry_get_animation_last =
      _spine_track_entry_get_animation_lastPtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_animation_last(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_animation_last(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_animation_lastPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_animation_last');
  late final _spine_track_entry_set_animation_last =
      _spine_track_entry_set_animation_lastPtr
          .asFunction<void Function(spine_track_entry, double)>();

  double spine_track_entry_get_animation_time(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_animation_time(
      self,
    );
  }

  late final _spine_track_entry_get_animation_timePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_animation_time');
  late final _spine_track_entry_get_animation_time =
      _spine_track_entry_get_animation_timePtr
          .asFunction<double Function(spine_track_entry)>();

  double spine_track_entry_get_time_scale(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_time_scale(
      self,
    );
  }

  late final _spine_track_entry_get_time_scalePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_time_scale');
  late final _spine_track_entry_get_time_scale =
      _spine_track_entry_get_time_scalePtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_time_scale(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_time_scale(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_time_scalePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_time_scale');
  late final _spine_track_entry_set_time_scale =
      _spine_track_entry_set_time_scalePtr
          .asFunction<void Function(spine_track_entry, double)>();

  double spine_track_entry_get_alpha(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_alpha(
      self,
    );
  }

  late final _spine_track_entry_get_alphaPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_alpha');
  late final _spine_track_entry_get_alpha = _spine_track_entry_get_alphaPtr
      .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_alpha(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_alpha(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_alphaPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_alpha');
  late final _spine_track_entry_set_alpha = _spine_track_entry_set_alphaPtr
      .asFunction<void Function(spine_track_entry, double)>();

  double spine_track_entry_get_event_threshold(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_event_threshold(
      self,
    );
  }

  late final _spine_track_entry_get_event_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_event_threshold');
  late final _spine_track_entry_get_event_threshold =
      _spine_track_entry_get_event_thresholdPtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_event_threshold(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_event_threshold(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_event_thresholdPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_event_threshold');
  late final _spine_track_entry_set_event_threshold =
      _spine_track_entry_set_event_thresholdPtr
          .asFunction<void Function(spine_track_entry, double)>();

  double spine_track_entry_get_mix_attachment_threshold(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mix_attachment_threshold(
      self,
    );
  }

  late final _spine_track_entry_get_mix_attachment_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_mix_attachment_threshold');
  late final _spine_track_entry_get_mix_attachment_threshold =
      _spine_track_entry_get_mix_attachment_thresholdPtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_mix_attachment_threshold(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_mix_attachment_threshold(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_mix_attachment_thresholdPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_mix_attachment_threshold');
  late final _spine_track_entry_set_mix_attachment_threshold =
      _spine_track_entry_set_mix_attachment_thresholdPtr
          .asFunction<void Function(spine_track_entry, double)>();

  double spine_track_entry_get_alpha_attachment_threshold(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_alpha_attachment_threshold(
      self,
    );
  }

  late final _spine_track_entry_get_alpha_attachment_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_alpha_attachment_threshold');
  late final _spine_track_entry_get_alpha_attachment_threshold =
      _spine_track_entry_get_alpha_attachment_thresholdPtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_alpha_attachment_threshold(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_alpha_attachment_threshold(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_alpha_attachment_thresholdPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_alpha_attachment_threshold');
  late final _spine_track_entry_set_alpha_attachment_threshold =
      _spine_track_entry_set_alpha_attachment_thresholdPtr
          .asFunction<void Function(spine_track_entry, double)>();

  double spine_track_entry_get_mix_draw_order_threshold(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mix_draw_order_threshold(
      self,
    );
  }

  late final _spine_track_entry_get_mix_draw_order_thresholdPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_mix_draw_order_threshold');
  late final _spine_track_entry_get_mix_draw_order_threshold =
      _spine_track_entry_get_mix_draw_order_thresholdPtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_mix_draw_order_threshold(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_mix_draw_order_threshold(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_mix_draw_order_thresholdPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_mix_draw_order_threshold');
  late final _spine_track_entry_set_mix_draw_order_threshold =
      _spine_track_entry_set_mix_draw_order_thresholdPtr
          .asFunction<void Function(spine_track_entry, double)>();

  spine_track_entry spine_track_entry_get_next(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_next(
      self,
    );
  }

  late final _spine_track_entry_get_nextPtr = _lookup<
          ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>(
      'spine_track_entry_get_next');
  late final _spine_track_entry_get_next = _spine_track_entry_get_nextPtr
      .asFunction<spine_track_entry Function(spine_track_entry)>();

  bool spine_track_entry_is_complete(
    spine_track_entry self,
  ) {
    return _spine_track_entry_is_complete(
      self,
    );
  }

  late final _spine_track_entry_is_completePtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>(
          'spine_track_entry_is_complete');
  late final _spine_track_entry_is_complete = _spine_track_entry_is_completePtr
      .asFunction<bool Function(spine_track_entry)>();

  double spine_track_entry_get_mix_time(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mix_time(
      self,
    );
  }

  late final _spine_track_entry_get_mix_timePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_mix_time');
  late final _spine_track_entry_get_mix_time =
      _spine_track_entry_get_mix_timePtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_mix_time(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_mix_time(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_mix_timePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_mix_time');
  late final _spine_track_entry_set_mix_time =
      _spine_track_entry_set_mix_timePtr
          .asFunction<void Function(spine_track_entry, double)>();

  double spine_track_entry_get_mix_duration(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mix_duration(
      self,
    );
  }

  late final _spine_track_entry_get_mix_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_mix_duration');
  late final _spine_track_entry_get_mix_duration =
      _spine_track_entry_get_mix_durationPtr
          .asFunction<double Function(spine_track_entry)>();

  void spine_track_entry_set_mix_duration_1(
    spine_track_entry self,
    double inValue,
  ) {
    return _spine_track_entry_set_mix_duration_1(
      self,
      inValue,
    );
  }

  late final _spine_track_entry_set_mix_duration_1Ptr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
      'spine_track_entry_set_mix_duration_1');
  late final _spine_track_entry_set_mix_duration_1 =
      _spine_track_entry_set_mix_duration_1Ptr
          .asFunction<void Function(spine_track_entry, double)>();

  void spine_track_entry_set_mix_duration_2(
    spine_track_entry self,
    double mixDuration,
    double delay,
  ) {
    return _spine_track_entry_set_mix_duration_2(
      self,
      mixDuration,
      delay,
    );
  }

  late final _spine_track_entry_set_mix_duration_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_track_entry, ffi.Float,
              ffi.Float)>>('spine_track_entry_set_mix_duration_2');
  late final _spine_track_entry_set_mix_duration_2 =
      _spine_track_entry_set_mix_duration_2Ptr
          .asFunction<void Function(spine_track_entry, double, double)>();

  int spine_track_entry_get_mix_blend(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mix_blend(
      self,
    );
  }

  late final _spine_track_entry_get_mix_blendPtr =
      _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
          'spine_track_entry_get_mix_blend');
  late final _spine_track_entry_get_mix_blend =
      _spine_track_entry_get_mix_blendPtr
          .asFunction<int Function(spine_track_entry)>();

  void spine_track_entry_set_mix_blend(
    spine_track_entry self,
    int blend,
  ) {
    return _spine_track_entry_set_mix_blend(
      self,
      blend,
    );
  }

  late final _spine_track_entry_set_mix_blendPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>(
      'spine_track_entry_set_mix_blend');
  late final _spine_track_entry_set_mix_blend =
      _spine_track_entry_set_mix_blendPtr
          .asFunction<void Function(spine_track_entry, int)>();

  spine_track_entry spine_track_entry_get_mixing_from(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mixing_from(
      self,
    );
  }

  late final _spine_track_entry_get_mixing_fromPtr = _lookup<
          ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>(
      'spine_track_entry_get_mixing_from');
  late final _spine_track_entry_get_mixing_from =
      _spine_track_entry_get_mixing_fromPtr
          .asFunction<spine_track_entry Function(spine_track_entry)>();

  spine_track_entry spine_track_entry_get_mixing_to(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_mixing_to(
      self,
    );
  }

  late final _spine_track_entry_get_mixing_toPtr = _lookup<
          ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>(
      'spine_track_entry_get_mixing_to');
  late final _spine_track_entry_get_mixing_to =
      _spine_track_entry_get_mixing_toPtr
          .asFunction<spine_track_entry Function(spine_track_entry)>();

  void spine_track_entry_reset_rotation_directions(
    spine_track_entry self,
  ) {
    return _spine_track_entry_reset_rotation_directions(
      self,
    );
  }

  late final _spine_track_entry_reset_rotation_directionsPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry)>>(
          'spine_track_entry_reset_rotation_directions');
  late final _spine_track_entry_reset_rotation_directions =
      _spine_track_entry_reset_rotation_directionsPtr
          .asFunction<void Function(spine_track_entry)>();

  double spine_track_entry_get_track_complete(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_track_complete(
      self,
    );
  }

  late final _spine_track_entry_get_track_completePtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
          'spine_track_entry_get_track_complete');
  late final _spine_track_entry_get_track_complete =
      _spine_track_entry_get_track_completePtr
          .asFunction<double Function(spine_track_entry)>();

  bool spine_track_entry_is_empty_animation(
    spine_track_entry self,
  ) {
    return _spine_track_entry_is_empty_animation(
      self,
    );
  }

  late final _spine_track_entry_is_empty_animationPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>(
          'spine_track_entry_is_empty_animation');
  late final _spine_track_entry_is_empty_animation =
      _spine_track_entry_is_empty_animationPtr
          .asFunction<bool Function(spine_track_entry)>();

  bool spine_track_entry_was_applied(
    spine_track_entry self,
  ) {
    return _spine_track_entry_was_applied(
      self,
    );
  }

  late final _spine_track_entry_was_appliedPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>(
          'spine_track_entry_was_applied');
  late final _spine_track_entry_was_applied = _spine_track_entry_was_appliedPtr
      .asFunction<bool Function(spine_track_entry)>();

  bool spine_track_entry_is_next_ready(
    spine_track_entry self,
  ) {
    return _spine_track_entry_is_next_ready(
      self,
    );
  }

  late final _spine_track_entry_is_next_readyPtr =
      _lookup<ffi.NativeFunction<ffi.Bool Function(spine_track_entry)>>(
          'spine_track_entry_is_next_ready');
  late final _spine_track_entry_is_next_ready =
      _spine_track_entry_is_next_readyPtr
          .asFunction<bool Function(spine_track_entry)>();

  ffi.Pointer<ffi.Void> spine_track_entry_get_renderer_object(
    spine_track_entry self,
  ) {
    return _spine_track_entry_get_renderer_object(
      self,
    );
  }

  late final _spine_track_entry_get_renderer_objectPtr = _lookup<
          ffi
          .NativeFunction<ffi.Pointer<ffi.Void> Function(spine_track_entry)>>(
      'spine_track_entry_get_renderer_object');
  late final _spine_track_entry_get_renderer_object =
      _spine_track_entry_get_renderer_objectPtr
          .asFunction<ffi.Pointer<ffi.Void> Function(spine_track_entry)>();

  spine_transform_constraint spine_transform_constraint_create(
    spine_transform_constraint_data data,
    spine_skeleton skeleton,
  ) {
    return _spine_transform_constraint_create(
      data,
      skeleton,
    );
  }

  late final _spine_transform_constraint_createPtr = _lookup<
      ffi.NativeFunction<
          spine_transform_constraint Function(spine_transform_constraint_data,
              spine_skeleton)>>('spine_transform_constraint_create');
  late final _spine_transform_constraint_create =
      _spine_transform_constraint_createPtr.asFunction<
          spine_transform_constraint Function(
              spine_transform_constraint_data, spine_skeleton)>();

  void spine_transform_constraint_dispose(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_dispose(
      self,
    );
  }

  late final _spine_transform_constraint_disposePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_transform_constraint)>>(
      'spine_transform_constraint_dispose');
  late final _spine_transform_constraint_dispose =
      _spine_transform_constraint_disposePtr
          .asFunction<void Function(spine_transform_constraint)>();

  spine_rtti spine_transform_constraint_get_rtti(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_get_rtti(
      self,
    );
  }

  late final _spine_transform_constraint_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_transform_constraint)>>(
      'spine_transform_constraint_get_rtti');
  late final _spine_transform_constraint_get_rtti =
      _spine_transform_constraint_get_rttiPtr
          .asFunction<spine_rtti Function(spine_transform_constraint)>();

  spine_transform_constraint spine_transform_constraint_copy(
    spine_transform_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_transform_constraint_copy(
      self,
      skeleton,
    );
  }

  late final _spine_transform_constraint_copyPtr = _lookup<
      ffi.NativeFunction<
          spine_transform_constraint Function(spine_transform_constraint,
              spine_skeleton)>>('spine_transform_constraint_copy');
  late final _spine_transform_constraint_copy =
      _spine_transform_constraint_copyPtr.asFunction<
          spine_transform_constraint Function(
              spine_transform_constraint, spine_skeleton)>();

  void spine_transform_constraint_update(
    spine_transform_constraint self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_transform_constraint_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_transform_constraint_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint, spine_skeleton,
              ffi.Int32)>>('spine_transform_constraint_update');
  late final _spine_transform_constraint_update =
      _spine_transform_constraint_updatePtr.asFunction<
          void Function(spine_transform_constraint, spine_skeleton, int)>();

  void spine_transform_constraint_sort(
    spine_transform_constraint self,
    spine_skeleton skeleton,
  ) {
    return _spine_transform_constraint_sort(
      self,
      skeleton,
    );
  }

  late final _spine_transform_constraint_sortPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint,
              spine_skeleton)>>('spine_transform_constraint_sort');
  late final _spine_transform_constraint_sort =
      _spine_transform_constraint_sortPtr.asFunction<
          void Function(spine_transform_constraint, spine_skeleton)>();

  bool spine_transform_constraint_is_source_active(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_is_source_active(
      self,
    );
  }

  late final _spine_transform_constraint_is_source_activePtr = _lookup<
          ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint)>>(
      'spine_transform_constraint_is_source_active');
  late final _spine_transform_constraint_is_source_active =
      _spine_transform_constraint_is_source_activePtr
          .asFunction<bool Function(spine_transform_constraint)>();

  spine_array_bone_pose spine_transform_constraint_get_bones(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_get_bones(
      self,
    );
  }

  late final _spine_transform_constraint_get_bonesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_bone_pose Function(spine_transform_constraint)>>(
      'spine_transform_constraint_get_bones');
  late final _spine_transform_constraint_get_bones =
      _spine_transform_constraint_get_bonesPtr.asFunction<
          spine_array_bone_pose Function(spine_transform_constraint)>();

  spine_bone spine_transform_constraint_get_source(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_get_source(
      self,
    );
  }

  late final _spine_transform_constraint_get_sourcePtr = _lookup<
          ffi.NativeFunction<spine_bone Function(spine_transform_constraint)>>(
      'spine_transform_constraint_get_source');
  late final _spine_transform_constraint_get_source =
      _spine_transform_constraint_get_sourcePtr
          .asFunction<spine_bone Function(spine_transform_constraint)>();

  void spine_transform_constraint_set_source(
    spine_transform_constraint self,
    spine_bone source,
  ) {
    return _spine_transform_constraint_set_source(
      self,
      source,
    );
  }

  late final _spine_transform_constraint_set_sourcePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint,
              spine_bone)>>('spine_transform_constraint_set_source');
  late final _spine_transform_constraint_set_source =
      _spine_transform_constraint_set_sourcePtr
          .asFunction<void Function(spine_transform_constraint, spine_bone)>();

  spine_transform_constraint_data spine_transform_constraint_get_data(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_get_data(
      self,
    );
  }

  late final _spine_transform_constraint_get_dataPtr = _lookup<
          ffi.NativeFunction<
              spine_transform_constraint_data Function(
                  spine_transform_constraint)>>(
      'spine_transform_constraint_get_data');
  late final _spine_transform_constraint_get_data =
      _spine_transform_constraint_get_dataPtr.asFunction<
          spine_transform_constraint_data Function(
              spine_transform_constraint)>();

  spine_transform_constraint_pose spine_transform_constraint_get_pose(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_get_pose(
      self,
    );
  }

  late final _spine_transform_constraint_get_posePtr = _lookup<
          ffi.NativeFunction<
              spine_transform_constraint_pose Function(
                  spine_transform_constraint)>>(
      'spine_transform_constraint_get_pose');
  late final _spine_transform_constraint_get_pose =
      _spine_transform_constraint_get_posePtr.asFunction<
          spine_transform_constraint_pose Function(
              spine_transform_constraint)>();

  spine_transform_constraint_pose spine_transform_constraint_get_applied_pose(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_get_applied_pose(
      self,
    );
  }

  late final _spine_transform_constraint_get_applied_posePtr = _lookup<
          ffi.NativeFunction<
              spine_transform_constraint_pose Function(
                  spine_transform_constraint)>>(
      'spine_transform_constraint_get_applied_pose');
  late final _spine_transform_constraint_get_applied_pose =
      _spine_transform_constraint_get_applied_posePtr.asFunction<
          spine_transform_constraint_pose Function(
              spine_transform_constraint)>();

  void spine_transform_constraint_reset_constrained(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_reset_constrained(
      self,
    );
  }

  late final _spine_transform_constraint_reset_constrainedPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_transform_constraint)>>(
      'spine_transform_constraint_reset_constrained');
  late final _spine_transform_constraint_reset_constrained =
      _spine_transform_constraint_reset_constrainedPtr
          .asFunction<void Function(spine_transform_constraint)>();

  void spine_transform_constraint_constrained(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_constrained(
      self,
    );
  }

  late final _spine_transform_constraint_constrainedPtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_transform_constraint)>>(
      'spine_transform_constraint_constrained');
  late final _spine_transform_constraint_constrained =
      _spine_transform_constraint_constrainedPtr
          .asFunction<void Function(spine_transform_constraint)>();

  bool spine_transform_constraint_is_pose_equal_to_applied(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_is_pose_equal_to_applied(
      self,
    );
  }

  late final _spine_transform_constraint_is_pose_equal_to_appliedPtr = _lookup<
          ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint)>>(
      'spine_transform_constraint_is_pose_equal_to_applied');
  late final _spine_transform_constraint_is_pose_equal_to_applied =
      _spine_transform_constraint_is_pose_equal_to_appliedPtr
          .asFunction<bool Function(spine_transform_constraint)>();

  bool spine_transform_constraint_is_active(
    spine_transform_constraint self,
  ) {
    return _spine_transform_constraint_is_active(
      self,
    );
  }

  late final _spine_transform_constraint_is_activePtr = _lookup<
          ffi.NativeFunction<ffi.Bool Function(spine_transform_constraint)>>(
      'spine_transform_constraint_is_active');
  late final _spine_transform_constraint_is_active =
      _spine_transform_constraint_is_activePtr
          .asFunction<bool Function(spine_transform_constraint)>();

  void spine_transform_constraint_set_active(
    spine_transform_constraint self,
    bool active,
  ) {
    return _spine_transform_constraint_set_active(
      self,
      active,
    );
  }

  late final _spine_transform_constraint_set_activePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint,
              ffi.Bool)>>('spine_transform_constraint_set_active');
  late final _spine_transform_constraint_set_active =
      _spine_transform_constraint_set_activePtr
          .asFunction<void Function(spine_transform_constraint, bool)>();

  spine_rtti spine_transform_constraint_rtti() {
    return _spine_transform_constraint_rtti();
  }

  late final _spine_transform_constraint_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_transform_constraint_rtti');
  late final _spine_transform_constraint_rtti =
      _spine_transform_constraint_rttiPtr.asFunction<spine_rtti Function()>();

  spine_transform_constraint_data spine_transform_constraint_data_create(
    ffi.Pointer<ffi.Char> name,
  ) {
    return _spine_transform_constraint_data_create(
      name,
    );
  }

  late final _spine_transform_constraint_data_createPtr = _lookup<
          ffi.NativeFunction<
              spine_transform_constraint_data Function(ffi.Pointer<ffi.Char>)>>(
      'spine_transform_constraint_data_create');
  late final _spine_transform_constraint_data_create =
      _spine_transform_constraint_data_createPtr.asFunction<
          spine_transform_constraint_data Function(ffi.Pointer<ffi.Char>)>();

  void spine_transform_constraint_data_dispose(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_dispose(
      self,
    );
  }

  late final _spine_transform_constraint_data_disposePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_dispose');
  late final _spine_transform_constraint_data_dispose =
      _spine_transform_constraint_data_disposePtr
          .asFunction<void Function(spine_transform_constraint_data)>();

  spine_rtti spine_transform_constraint_data_get_rtti(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_rtti(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_rtti');
  late final _spine_transform_constraint_data_get_rtti =
      _spine_transform_constraint_data_get_rttiPtr
          .asFunction<spine_rtti Function(spine_transform_constraint_data)>();

  spine_constraint spine_transform_constraint_data_create_method(
    spine_transform_constraint_data self,
    spine_skeleton skeleton,
  ) {
    return _spine_transform_constraint_data_create_method(
      self,
      skeleton,
    );
  }

  late final _spine_transform_constraint_data_create_methodPtr = _lookup<
          ffi.NativeFunction<
              spine_constraint Function(
                  spine_transform_constraint_data, spine_skeleton)>>(
      'spine_transform_constraint_data_create_method');
  late final _spine_transform_constraint_data_create_method =
      _spine_transform_constraint_data_create_methodPtr.asFunction<
          spine_constraint Function(
              spine_transform_constraint_data, spine_skeleton)>();

  spine_array_bone_data spine_transform_constraint_data_get_bones(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_bones(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_bonesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_bone_data Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_bones');
  late final _spine_transform_constraint_data_get_bones =
      _spine_transform_constraint_data_get_bonesPtr.asFunction<
          spine_array_bone_data Function(spine_transform_constraint_data)>();

  spine_bone_data spine_transform_constraint_data_get_source(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_source(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_sourcePtr = _lookup<
          ffi.NativeFunction<
              spine_bone_data Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_source');
  late final _spine_transform_constraint_data_get_source =
      _spine_transform_constraint_data_get_sourcePtr.asFunction<
          spine_bone_data Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_source(
    spine_transform_constraint_data self,
    spine_bone_data source,
  ) {
    return _spine_transform_constraint_data_set_source(
      self,
      source,
    );
  }

  late final _spine_transform_constraint_data_set_sourcePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_data,
              spine_bone_data)>>('spine_transform_constraint_data_set_source');
  late final _spine_transform_constraint_data_set_source =
      _spine_transform_constraint_data_set_sourcePtr.asFunction<
          void Function(spine_transform_constraint_data, spine_bone_data)>();

  double spine_transform_constraint_data_get_offset_rotation(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_offset_rotation(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_offset_rotationPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_offset_rotation');
  late final _spine_transform_constraint_data_get_offset_rotation =
      _spine_transform_constraint_data_get_offset_rotationPtr
          .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_offset_rotation(
    spine_transform_constraint_data self,
    double offsetRotation,
  ) {
    return _spine_transform_constraint_data_set_offset_rotation(
      self,
      offsetRotation,
    );
  }

  late final _spine_transform_constraint_data_set_offset_rotationPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
      'spine_transform_constraint_data_set_offset_rotation');
  late final _spine_transform_constraint_data_set_offset_rotation =
      _spine_transform_constraint_data_set_offset_rotationPtr
          .asFunction<void Function(spine_transform_constraint_data, double)>();

  double spine_transform_constraint_data_get_offset_x(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_offset_x(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_offset_xPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_offset_x');
  late final _spine_transform_constraint_data_get_offset_x =
      _spine_transform_constraint_data_get_offset_xPtr
          .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_offset_x(
    spine_transform_constraint_data self,
    double offsetX,
  ) {
    return _spine_transform_constraint_data_set_offset_x(
      self,
      offsetX,
    );
  }

  late final _spine_transform_constraint_data_set_offset_xPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_data,
              ffi.Float)>>('spine_transform_constraint_data_set_offset_x');
  late final _spine_transform_constraint_data_set_offset_x =
      _spine_transform_constraint_data_set_offset_xPtr
          .asFunction<void Function(spine_transform_constraint_data, double)>();

  double spine_transform_constraint_data_get_offset_y(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_offset_y(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_offset_yPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_offset_y');
  late final _spine_transform_constraint_data_get_offset_y =
      _spine_transform_constraint_data_get_offset_yPtr
          .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_offset_y(
    spine_transform_constraint_data self,
    double offsetY,
  ) {
    return _spine_transform_constraint_data_set_offset_y(
      self,
      offsetY,
    );
  }

  late final _spine_transform_constraint_data_set_offset_yPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_data,
              ffi.Float)>>('spine_transform_constraint_data_set_offset_y');
  late final _spine_transform_constraint_data_set_offset_y =
      _spine_transform_constraint_data_set_offset_yPtr
          .asFunction<void Function(spine_transform_constraint_data, double)>();

  double spine_transform_constraint_data_get_offset_scale_x(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_offset_scale_x(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_offset_scale_xPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_offset_scale_x');
  late final _spine_transform_constraint_data_get_offset_scale_x =
      _spine_transform_constraint_data_get_offset_scale_xPtr
          .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_offset_scale_x(
    spine_transform_constraint_data self,
    double offsetScaleX,
  ) {
    return _spine_transform_constraint_data_set_offset_scale_x(
      self,
      offsetScaleX,
    );
  }

  late final _spine_transform_constraint_data_set_offset_scale_xPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
      'spine_transform_constraint_data_set_offset_scale_x');
  late final _spine_transform_constraint_data_set_offset_scale_x =
      _spine_transform_constraint_data_set_offset_scale_xPtr
          .asFunction<void Function(spine_transform_constraint_data, double)>();

  double spine_transform_constraint_data_get_offset_scale_y(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_offset_scale_y(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_offset_scale_yPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_offset_scale_y');
  late final _spine_transform_constraint_data_get_offset_scale_y =
      _spine_transform_constraint_data_get_offset_scale_yPtr
          .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_offset_scale_y(
    spine_transform_constraint_data self,
    double offsetScaleY,
  ) {
    return _spine_transform_constraint_data_set_offset_scale_y(
      self,
      offsetScaleY,
    );
  }

  late final _spine_transform_constraint_data_set_offset_scale_yPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
      'spine_transform_constraint_data_set_offset_scale_y');
  late final _spine_transform_constraint_data_set_offset_scale_y =
      _spine_transform_constraint_data_set_offset_scale_yPtr
          .asFunction<void Function(spine_transform_constraint_data, double)>();

  double spine_transform_constraint_data_get_offset_shear_y(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_offset_shear_y(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_offset_shear_yPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_offset_shear_y');
  late final _spine_transform_constraint_data_get_offset_shear_y =
      _spine_transform_constraint_data_get_offset_shear_yPtr
          .asFunction<double Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_offset_shear_y(
    spine_transform_constraint_data self,
    double offsetShearY,
  ) {
    return _spine_transform_constraint_data_set_offset_shear_y(
      self,
      offsetShearY,
    );
  }

  late final _spine_transform_constraint_data_set_offset_shear_yPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
      'spine_transform_constraint_data_set_offset_shear_y');
  late final _spine_transform_constraint_data_set_offset_shear_y =
      _spine_transform_constraint_data_set_offset_shear_yPtr
          .asFunction<void Function(spine_transform_constraint_data, double)>();

  bool spine_transform_constraint_data_get_local_source(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_local_source(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_local_sourcePtr = _lookup<
          ffi
          .NativeFunction<ffi.Bool Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_local_source');
  late final _spine_transform_constraint_data_get_local_source =
      _spine_transform_constraint_data_get_local_sourcePtr
          .asFunction<bool Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_local_source(
    spine_transform_constraint_data self,
    bool localSource,
  ) {
    return _spine_transform_constraint_data_set_local_source(
      self,
      localSource,
    );
  }

  late final _spine_transform_constraint_data_set_local_sourcePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_data,
              ffi.Bool)>>('spine_transform_constraint_data_set_local_source');
  late final _spine_transform_constraint_data_set_local_source =
      _spine_transform_constraint_data_set_local_sourcePtr
          .asFunction<void Function(spine_transform_constraint_data, bool)>();

  bool spine_transform_constraint_data_get_local_target(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_local_target(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_local_targetPtr = _lookup<
          ffi
          .NativeFunction<ffi.Bool Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_local_target');
  late final _spine_transform_constraint_data_get_local_target =
      _spine_transform_constraint_data_get_local_targetPtr
          .asFunction<bool Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_local_target(
    spine_transform_constraint_data self,
    bool localTarget,
  ) {
    return _spine_transform_constraint_data_set_local_target(
      self,
      localTarget,
    );
  }

  late final _spine_transform_constraint_data_set_local_targetPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_data,
              ffi.Bool)>>('spine_transform_constraint_data_set_local_target');
  late final _spine_transform_constraint_data_set_local_target =
      _spine_transform_constraint_data_set_local_targetPtr
          .asFunction<void Function(spine_transform_constraint_data, bool)>();

  bool spine_transform_constraint_data_get_additive(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_additive(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_additivePtr = _lookup<
          ffi
          .NativeFunction<ffi.Bool Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_additive');
  late final _spine_transform_constraint_data_get_additive =
      _spine_transform_constraint_data_get_additivePtr
          .asFunction<bool Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_additive(
    spine_transform_constraint_data self,
    bool additive,
  ) {
    return _spine_transform_constraint_data_set_additive(
      self,
      additive,
    );
  }

  late final _spine_transform_constraint_data_set_additivePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_data,
              ffi.Bool)>>('spine_transform_constraint_data_set_additive');
  late final _spine_transform_constraint_data_set_additive =
      _spine_transform_constraint_data_set_additivePtr
          .asFunction<void Function(spine_transform_constraint_data, bool)>();

  bool spine_transform_constraint_data_get_clamp(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_clamp(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_clampPtr = _lookup<
          ffi
          .NativeFunction<ffi.Bool Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_clamp');
  late final _spine_transform_constraint_data_get_clamp =
      _spine_transform_constraint_data_get_clampPtr
          .asFunction<bool Function(spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_clamp(
    spine_transform_constraint_data self,
    bool clamp,
  ) {
    return _spine_transform_constraint_data_set_clamp(
      self,
      clamp,
    );
  }

  late final _spine_transform_constraint_data_set_clampPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_data,
              ffi.Bool)>>('spine_transform_constraint_data_set_clamp');
  late final _spine_transform_constraint_data_set_clamp =
      _spine_transform_constraint_data_set_clampPtr
          .asFunction<void Function(spine_transform_constraint_data, bool)>();

  spine_array_from_property spine_transform_constraint_data_get_properties(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_properties(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_propertiesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_from_property Function(
                  spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_properties');
  late final _spine_transform_constraint_data_get_properties =
      _spine_transform_constraint_data_get_propertiesPtr.asFunction<
          spine_array_from_property Function(
              spine_transform_constraint_data)>();

  ffi.Pointer<ffi.Char> spine_transform_constraint_data_get_name(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_name(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_namePtr = _lookup<
          ffi.NativeFunction<
              ffi.Pointer<ffi.Char> Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_name');
  late final _spine_transform_constraint_data_get_name =
      _spine_transform_constraint_data_get_namePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(spine_transform_constraint_data)>();

  bool spine_transform_constraint_data_get_skin_required(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_skin_required(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_skin_requiredPtr = _lookup<
          ffi
          .NativeFunction<ffi.Bool Function(spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_skin_required');
  late final _spine_transform_constraint_data_get_skin_required =
      _spine_transform_constraint_data_get_skin_requiredPtr
          .asFunction<bool Function(spine_transform_constraint_data)>();

  spine_transform_constraint_pose
      spine_transform_constraint_data_get_setup_pose(
    spine_transform_constraint_data self,
  ) {
    return _spine_transform_constraint_data_get_setup_pose(
      self,
    );
  }

  late final _spine_transform_constraint_data_get_setup_posePtr = _lookup<
          ffi.NativeFunction<
              spine_transform_constraint_pose Function(
                  spine_transform_constraint_data)>>(
      'spine_transform_constraint_data_get_setup_pose');
  late final _spine_transform_constraint_data_get_setup_pose =
      _spine_transform_constraint_data_get_setup_posePtr.asFunction<
          spine_transform_constraint_pose Function(
              spine_transform_constraint_data)>();

  void spine_transform_constraint_data_set_skin_required(
    spine_transform_constraint_data self,
    bool skinRequired,
  ) {
    return _spine_transform_constraint_data_set_skin_required(
      self,
      skinRequired,
    );
  }

  late final _spine_transform_constraint_data_set_skin_requiredPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_data,
              ffi.Bool)>>('spine_transform_constraint_data_set_skin_required');
  late final _spine_transform_constraint_data_set_skin_required =
      _spine_transform_constraint_data_set_skin_requiredPtr
          .asFunction<void Function(spine_transform_constraint_data, bool)>();

  spine_rtti spine_transform_constraint_data_rtti() {
    return _spine_transform_constraint_data_rtti();
  }

  late final _spine_transform_constraint_data_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_transform_constraint_data_rtti');
  late final _spine_transform_constraint_data_rtti =
      _spine_transform_constraint_data_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_transform_constraint_pose spine_transform_constraint_pose_create() {
    return _spine_transform_constraint_pose_create();
  }

  late final _spine_transform_constraint_pose_createPtr =
      _lookup<ffi.NativeFunction<spine_transform_constraint_pose Function()>>(
          'spine_transform_constraint_pose_create');
  late final _spine_transform_constraint_pose_create =
      _spine_transform_constraint_pose_createPtr
          .asFunction<spine_transform_constraint_pose Function()>();

  void spine_transform_constraint_pose_dispose(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_dispose(
      self,
    );
  }

  late final _spine_transform_constraint_pose_disposePtr = _lookup<
          ffi
          .NativeFunction<ffi.Void Function(spine_transform_constraint_pose)>>(
      'spine_transform_constraint_pose_dispose');
  late final _spine_transform_constraint_pose_dispose =
      _spine_transform_constraint_pose_disposePtr
          .asFunction<void Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set(
    spine_transform_constraint_pose self,
    spine_transform_constraint_pose pose,
  ) {
    return _spine_transform_constraint_pose_set(
      self,
      pose,
    );
  }

  late final _spine_transform_constraint_pose_setPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_transform_constraint_pose,
                  spine_transform_constraint_pose)>>(
      'spine_transform_constraint_pose_set');
  late final _spine_transform_constraint_pose_set =
      _spine_transform_constraint_pose_setPtr.asFunction<
          void Function(spine_transform_constraint_pose,
              spine_transform_constraint_pose)>();

  double spine_transform_constraint_pose_get_mix_rotate(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_get_mix_rotate(
      self,
    );
  }

  late final _spine_transform_constraint_pose_get_mix_rotatePtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_transform_constraint_pose)>>(
      'spine_transform_constraint_pose_get_mix_rotate');
  late final _spine_transform_constraint_pose_get_mix_rotate =
      _spine_transform_constraint_pose_get_mix_rotatePtr
          .asFunction<double Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set_mix_rotate(
    spine_transform_constraint_pose self,
    double mixRotate,
  ) {
    return _spine_transform_constraint_pose_set_mix_rotate(
      self,
      mixRotate,
    );
  }

  late final _spine_transform_constraint_pose_set_mix_rotatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_pose,
              ffi.Float)>>('spine_transform_constraint_pose_set_mix_rotate');
  late final _spine_transform_constraint_pose_set_mix_rotate =
      _spine_transform_constraint_pose_set_mix_rotatePtr
          .asFunction<void Function(spine_transform_constraint_pose, double)>();

  double spine_transform_constraint_pose_get_mix_x(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_get_mix_x(
      self,
    );
  }

  late final _spine_transform_constraint_pose_get_mix_xPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_transform_constraint_pose)>>(
      'spine_transform_constraint_pose_get_mix_x');
  late final _spine_transform_constraint_pose_get_mix_x =
      _spine_transform_constraint_pose_get_mix_xPtr
          .asFunction<double Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set_mix_x(
    spine_transform_constraint_pose self,
    double mixX,
  ) {
    return _spine_transform_constraint_pose_set_mix_x(
      self,
      mixX,
    );
  }

  late final _spine_transform_constraint_pose_set_mix_xPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_pose,
              ffi.Float)>>('spine_transform_constraint_pose_set_mix_x');
  late final _spine_transform_constraint_pose_set_mix_x =
      _spine_transform_constraint_pose_set_mix_xPtr
          .asFunction<void Function(spine_transform_constraint_pose, double)>();

  double spine_transform_constraint_pose_get_mix_y(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_get_mix_y(
      self,
    );
  }

  late final _spine_transform_constraint_pose_get_mix_yPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_transform_constraint_pose)>>(
      'spine_transform_constraint_pose_get_mix_y');
  late final _spine_transform_constraint_pose_get_mix_y =
      _spine_transform_constraint_pose_get_mix_yPtr
          .asFunction<double Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set_mix_y(
    spine_transform_constraint_pose self,
    double mixY,
  ) {
    return _spine_transform_constraint_pose_set_mix_y(
      self,
      mixY,
    );
  }

  late final _spine_transform_constraint_pose_set_mix_yPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_pose,
              ffi.Float)>>('spine_transform_constraint_pose_set_mix_y');
  late final _spine_transform_constraint_pose_set_mix_y =
      _spine_transform_constraint_pose_set_mix_yPtr
          .asFunction<void Function(spine_transform_constraint_pose, double)>();

  double spine_transform_constraint_pose_get_mix_scale_x(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_get_mix_scale_x(
      self,
    );
  }

  late final _spine_transform_constraint_pose_get_mix_scale_xPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_transform_constraint_pose)>>(
      'spine_transform_constraint_pose_get_mix_scale_x');
  late final _spine_transform_constraint_pose_get_mix_scale_x =
      _spine_transform_constraint_pose_get_mix_scale_xPtr
          .asFunction<double Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set_mix_scale_x(
    spine_transform_constraint_pose self,
    double mixScaleX,
  ) {
    return _spine_transform_constraint_pose_set_mix_scale_x(
      self,
      mixScaleX,
    );
  }

  late final _spine_transform_constraint_pose_set_mix_scale_xPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_pose,
              ffi.Float)>>('spine_transform_constraint_pose_set_mix_scale_x');
  late final _spine_transform_constraint_pose_set_mix_scale_x =
      _spine_transform_constraint_pose_set_mix_scale_xPtr
          .asFunction<void Function(spine_transform_constraint_pose, double)>();

  double spine_transform_constraint_pose_get_mix_scale_y(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_get_mix_scale_y(
      self,
    );
  }

  late final _spine_transform_constraint_pose_get_mix_scale_yPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_transform_constraint_pose)>>(
      'spine_transform_constraint_pose_get_mix_scale_y');
  late final _spine_transform_constraint_pose_get_mix_scale_y =
      _spine_transform_constraint_pose_get_mix_scale_yPtr
          .asFunction<double Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set_mix_scale_y(
    spine_transform_constraint_pose self,
    double mixScaleY,
  ) {
    return _spine_transform_constraint_pose_set_mix_scale_y(
      self,
      mixScaleY,
    );
  }

  late final _spine_transform_constraint_pose_set_mix_scale_yPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_pose,
              ffi.Float)>>('spine_transform_constraint_pose_set_mix_scale_y');
  late final _spine_transform_constraint_pose_set_mix_scale_y =
      _spine_transform_constraint_pose_set_mix_scale_yPtr
          .asFunction<void Function(spine_transform_constraint_pose, double)>();

  double spine_transform_constraint_pose_get_mix_shear_y(
    spine_transform_constraint_pose self,
  ) {
    return _spine_transform_constraint_pose_get_mix_shear_y(
      self,
    );
  }

  late final _spine_transform_constraint_pose_get_mix_shear_yPtr = _lookup<
          ffi
          .NativeFunction<ffi.Float Function(spine_transform_constraint_pose)>>(
      'spine_transform_constraint_pose_get_mix_shear_y');
  late final _spine_transform_constraint_pose_get_mix_shear_y =
      _spine_transform_constraint_pose_get_mix_shear_yPtr
          .asFunction<double Function(spine_transform_constraint_pose)>();

  void spine_transform_constraint_pose_set_mix_shear_y(
    spine_transform_constraint_pose self,
    double mixShearY,
  ) {
    return _spine_transform_constraint_pose_set_mix_shear_y(
      self,
      mixShearY,
    );
  }

  late final _spine_transform_constraint_pose_set_mix_shear_yPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_pose,
              ffi.Float)>>('spine_transform_constraint_pose_set_mix_shear_y');
  late final _spine_transform_constraint_pose_set_mix_shear_y =
      _spine_transform_constraint_pose_set_mix_shear_yPtr
          .asFunction<void Function(spine_transform_constraint_pose, double)>();

  spine_transform_constraint_timeline
      spine_transform_constraint_timeline_create(
    int frameCount,
    int bezierCount,
    int transformConstraintIndex,
  ) {
    return _spine_transform_constraint_timeline_create(
      frameCount,
      bezierCount,
      transformConstraintIndex,
    );
  }

  late final _spine_transform_constraint_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_transform_constraint_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_transform_constraint_timeline_create');
  late final _spine_transform_constraint_timeline_create =
      _spine_transform_constraint_timeline_createPtr.asFunction<
          spine_transform_constraint_timeline Function(int, int, int)>();

  void spine_transform_constraint_timeline_dispose(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_dispose(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_disposePtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_transform_constraint_timeline)>>(
      'spine_transform_constraint_timeline_dispose');
  late final _spine_transform_constraint_timeline_dispose =
      _spine_transform_constraint_timeline_disposePtr
          .asFunction<void Function(spine_transform_constraint_timeline)>();

  spine_rtti spine_transform_constraint_timeline_get_rtti(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_rtti(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<
              spine_rtti Function(spine_transform_constraint_timeline)>>(
      'spine_transform_constraint_timeline_get_rtti');
  late final _spine_transform_constraint_timeline_get_rtti =
      _spine_transform_constraint_timeline_get_rttiPtr.asFunction<
          spine_rtti Function(spine_transform_constraint_timeline)>();

  void spine_transform_constraint_timeline_apply(
    spine_transform_constraint_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_transform_constraint_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_transform_constraint_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_transform_constraint_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_transform_constraint_timeline_apply');
  late final _spine_transform_constraint_timeline_apply =
      _spine_transform_constraint_timeline_applyPtr.asFunction<
          void Function(spine_transform_constraint_timeline, spine_skeleton,
              double, double, spine_array_event, double, int, int, bool)>();

  void spine_transform_constraint_timeline_set_frame(
    spine_transform_constraint_timeline self,
    int frame,
    double time,
    double mixRotate,
    double mixX,
    double mixY,
    double mixScaleX,
    double mixScaleY,
    double mixShearY,
  ) {
    return _spine_transform_constraint_timeline_set_frame(
      self,
      frame,
      time,
      mixRotate,
      mixX,
      mixY,
      mixScaleX,
      mixScaleY,
      mixShearY,
    );
  }

  late final _spine_transform_constraint_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_transform_constraint_timeline,
              ffi.Int,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_transform_constraint_timeline_set_frame');
  late final _spine_transform_constraint_timeline_set_frame =
      _spine_transform_constraint_timeline_set_framePtr.asFunction<
          void Function(spine_transform_constraint_timeline, int, double,
              double, double, double, double, double, double)>();

  void spine_transform_constraint_timeline_set_linear(
    spine_transform_constraint_timeline self,
    int frame,
  ) {
    return _spine_transform_constraint_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_transform_constraint_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_timeline,
              ffi.Size)>>('spine_transform_constraint_timeline_set_linear');
  late final _spine_transform_constraint_timeline_set_linear =
      _spine_transform_constraint_timeline_set_linearPtr.asFunction<
          void Function(spine_transform_constraint_timeline, int)>();

  void spine_transform_constraint_timeline_set_stepped(
    spine_transform_constraint_timeline self,
    int frame,
  ) {
    return _spine_transform_constraint_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_transform_constraint_timeline_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_transform_constraint_timeline,
              ffi.Size)>>('spine_transform_constraint_timeline_set_stepped');
  late final _spine_transform_constraint_timeline_set_stepped =
      _spine_transform_constraint_timeline_set_steppedPtr.asFunction<
          void Function(spine_transform_constraint_timeline, int)>();

  void spine_transform_constraint_timeline_set_bezier(
    spine_transform_constraint_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_transform_constraint_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_transform_constraint_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_transform_constraint_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_transform_constraint_timeline_set_bezier');
  late final _spine_transform_constraint_timeline_set_bezier =
      _spine_transform_constraint_timeline_set_bezierPtr.asFunction<
          void Function(
              spine_transform_constraint_timeline,
              int,
              int,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double,
              double)>();

  double spine_transform_constraint_timeline_get_bezier_value(
    spine_transform_constraint_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_transform_constraint_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_transform_constraint_timeline_get_bezier_valuePtr = _lookup<
          ffi.NativeFunction<
              ffi.Float Function(spine_transform_constraint_timeline, ffi.Float,
                  ffi.Size, ffi.Size, ffi.Size)>>(
      'spine_transform_constraint_timeline_get_bezier_value');
  late final _spine_transform_constraint_timeline_get_bezier_value =
      _spine_transform_constraint_timeline_get_bezier_valuePtr.asFunction<
          double Function(
              spine_transform_constraint_timeline, double, int, int, int)>();

  spine_array_float spine_transform_constraint_timeline_get_curves(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_curves(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_transform_constraint_timeline)>>(
      'spine_transform_constraint_timeline_get_curves');
  late final _spine_transform_constraint_timeline_get_curves =
      _spine_transform_constraint_timeline_get_curvesPtr.asFunction<
          spine_array_float Function(spine_transform_constraint_timeline)>();

  int spine_transform_constraint_timeline_get_frame_entries(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_frame_entriesPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Size Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_get_frame_entries');
  late final _spine_transform_constraint_timeline_get_frame_entries =
      _spine_transform_constraint_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_transform_constraint_timeline)>();

  int spine_transform_constraint_timeline_get_frame_count(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_frame_countPtr = _lookup<
          ffi.NativeFunction<
              ffi.Size Function(spine_transform_constraint_timeline)>>(
      'spine_transform_constraint_timeline_get_frame_count');
  late final _spine_transform_constraint_timeline_get_frame_count =
      _spine_transform_constraint_timeline_get_frame_countPtr
          .asFunction<int Function(spine_transform_constraint_timeline)>();

  spine_array_float spine_transform_constraint_timeline_get_frames(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_frames(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_transform_constraint_timeline)>>(
      'spine_transform_constraint_timeline_get_frames');
  late final _spine_transform_constraint_timeline_get_frames =
      _spine_transform_constraint_timeline_get_framesPtr.asFunction<
          spine_array_float Function(spine_transform_constraint_timeline)>();

  double spine_transform_constraint_timeline_get_duration(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_duration(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<
              ffi.Float Function(spine_transform_constraint_timeline)>>(
      'spine_transform_constraint_timeline_get_duration');
  late final _spine_transform_constraint_timeline_get_duration =
      _spine_transform_constraint_timeline_get_durationPtr
          .asFunction<double Function(spine_transform_constraint_timeline)>();

  spine_array_property_id spine_transform_constraint_timeline_get_property_ids(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(
                  spine_transform_constraint_timeline)>>(
      'spine_transform_constraint_timeline_get_property_ids');
  late final _spine_transform_constraint_timeline_get_property_ids =
      _spine_transform_constraint_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(
              spine_transform_constraint_timeline)>();

  int spine_transform_constraint_timeline_get_constraint_index(
    spine_transform_constraint_timeline self,
  ) {
    return _spine_transform_constraint_timeline_get_constraint_index(
      self,
    );
  }

  late final _spine_transform_constraint_timeline_get_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Int Function(spine_transform_constraint_timeline)>>(
          'spine_transform_constraint_timeline_get_constraint_index');
  late final _spine_transform_constraint_timeline_get_constraint_index =
      _spine_transform_constraint_timeline_get_constraint_indexPtr
          .asFunction<int Function(spine_transform_constraint_timeline)>();

  void spine_transform_constraint_timeline_set_constraint_index(
    spine_transform_constraint_timeline self,
    int inValue,
  ) {
    return _spine_transform_constraint_timeline_set_constraint_index(
      self,
      inValue,
    );
  }

  late final _spine_transform_constraint_timeline_set_constraint_indexPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      spine_transform_constraint_timeline, ffi.Int)>>(
          'spine_transform_constraint_timeline_set_constraint_index');
  late final _spine_transform_constraint_timeline_set_constraint_index =
      _spine_transform_constraint_timeline_set_constraint_indexPtr.asFunction<
          void Function(spine_transform_constraint_timeline, int)>();

  spine_rtti spine_transform_constraint_timeline_rtti() {
    return _spine_transform_constraint_timeline_rtti();
  }

  late final _spine_transform_constraint_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_transform_constraint_timeline_rtti');
  late final _spine_transform_constraint_timeline_rtti =
      _spine_transform_constraint_timeline_rttiPtr
          .asFunction<spine_rtti Function()>();

  spine_translate_timeline spine_translate_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_translate_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_translate_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_translate_timeline Function(
              ffi.Size, ffi.Size, ffi.Int)>>('spine_translate_timeline_create');
  late final _spine_translate_timeline_create =
      _spine_translate_timeline_createPtr
          .asFunction<spine_translate_timeline Function(int, int, int)>();

  void spine_translate_timeline_dispose(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_dispose(
      self,
    );
  }

  late final _spine_translate_timeline_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_translate_timeline)>>(
          'spine_translate_timeline_dispose');
  late final _spine_translate_timeline_dispose =
      _spine_translate_timeline_disposePtr
          .asFunction<void Function(spine_translate_timeline)>();

  spine_rtti spine_translate_timeline_get_rtti(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_rtti(
      self,
    );
  }

  late final _spine_translate_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_translate_timeline)>>(
      'spine_translate_timeline_get_rtti');
  late final _spine_translate_timeline_get_rtti =
      _spine_translate_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_translate_timeline)>();

  void spine_translate_timeline_apply(
    spine_translate_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_translate_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_translate_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_translate_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_translate_timeline_apply');
  late final _spine_translate_timeline_apply =
      _spine_translate_timeline_applyPtr.asFunction<
          void Function(spine_translate_timeline, spine_skeleton, double,
              double, spine_array_event, double, int, int, bool)>();

  void spine_translate_timeline_set_frame(
    spine_translate_timeline self,
    int frame,
    double time,
    double value1,
    double value2,
  ) {
    return _spine_translate_timeline_set_frame(
      self,
      frame,
      time,
      value1,
      value2,
    );
  }

  late final _spine_translate_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_timeline, ffi.Size, ffi.Float,
              ffi.Float, ffi.Float)>>('spine_translate_timeline_set_frame');
  late final _spine_translate_timeline_set_frame =
      _spine_translate_timeline_set_framePtr.asFunction<
          void Function(
              spine_translate_timeline, int, double, double, double)>();

  double spine_translate_timeline_get_curve_value(
    spine_translate_timeline self,
    double time,
  ) {
    return _spine_translate_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_translate_timeline_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_translate_timeline,
              ffi.Float)>>('spine_translate_timeline_get_curve_value');
  late final _spine_translate_timeline_get_curve_value =
      _spine_translate_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_translate_timeline, double)>();

  void spine_translate_timeline_set_linear(
    spine_translate_timeline self,
    int frame,
  ) {
    return _spine_translate_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_translate_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_timeline,
              ffi.Size)>>('spine_translate_timeline_set_linear');
  late final _spine_translate_timeline_set_linear =
      _spine_translate_timeline_set_linearPtr
          .asFunction<void Function(spine_translate_timeline, int)>();

  void spine_translate_timeline_set_stepped(
    spine_translate_timeline self,
    int frame,
  ) {
    return _spine_translate_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_translate_timeline_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_timeline,
              ffi.Size)>>('spine_translate_timeline_set_stepped');
  late final _spine_translate_timeline_set_stepped =
      _spine_translate_timeline_set_steppedPtr
          .asFunction<void Function(spine_translate_timeline, int)>();

  void spine_translate_timeline_set_bezier(
    spine_translate_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_translate_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_translate_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_translate_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_translate_timeline_set_bezier');
  late final _spine_translate_timeline_set_bezier =
      _spine_translate_timeline_set_bezierPtr.asFunction<
          void Function(spine_translate_timeline, int, int, double, double,
              double, double, double, double, double, double, double)>();

  double spine_translate_timeline_get_bezier_value(
    spine_translate_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_translate_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_translate_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_translate_timeline,
              ffi.Float,
              ffi.Size,
              ffi.Size,
              ffi.Size)>>('spine_translate_timeline_get_bezier_value');
  late final _spine_translate_timeline_get_bezier_value =
      _spine_translate_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_translate_timeline, double, int, int, int)>();

  spine_array_float spine_translate_timeline_get_curves(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_curves(
      self,
    );
  }

  late final _spine_translate_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_translate_timeline)>>(
      'spine_translate_timeline_get_curves');
  late final _spine_translate_timeline_get_curves =
      _spine_translate_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_translate_timeline)>();

  int spine_translate_timeline_get_frame_entries(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_translate_timeline_get_frame_entriesPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_translate_timeline)>>(
          'spine_translate_timeline_get_frame_entries');
  late final _spine_translate_timeline_get_frame_entries =
      _spine_translate_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_translate_timeline)>();

  int spine_translate_timeline_get_frame_count(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_translate_timeline_get_frame_countPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_translate_timeline)>>(
          'spine_translate_timeline_get_frame_count');
  late final _spine_translate_timeline_get_frame_count =
      _spine_translate_timeline_get_frame_countPtr
          .asFunction<int Function(spine_translate_timeline)>();

  spine_array_float spine_translate_timeline_get_frames(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_frames(
      self,
    );
  }

  late final _spine_translate_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_translate_timeline)>>(
      'spine_translate_timeline_get_frames');
  late final _spine_translate_timeline_get_frames =
      _spine_translate_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_translate_timeline)>();

  double spine_translate_timeline_get_duration(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_duration(
      self,
    );
  }

  late final _spine_translate_timeline_get_durationPtr =
      _lookup<ffi.NativeFunction<ffi.Float Function(spine_translate_timeline)>>(
          'spine_translate_timeline_get_duration');
  late final _spine_translate_timeline_get_duration =
      _spine_translate_timeline_get_durationPtr
          .asFunction<double Function(spine_translate_timeline)>();

  spine_array_property_id spine_translate_timeline_get_property_ids(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_translate_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_translate_timeline)>>(
      'spine_translate_timeline_get_property_ids');
  late final _spine_translate_timeline_get_property_ids =
      _spine_translate_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_translate_timeline)>();

  int spine_translate_timeline_get_bone_index(
    spine_translate_timeline self,
  ) {
    return _spine_translate_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_translate_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_translate_timeline)>>(
          'spine_translate_timeline_get_bone_index');
  late final _spine_translate_timeline_get_bone_index =
      _spine_translate_timeline_get_bone_indexPtr
          .asFunction<int Function(spine_translate_timeline)>();

  void spine_translate_timeline_set_bone_index(
    spine_translate_timeline self,
    int inValue,
  ) {
    return _spine_translate_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_translate_timeline_set_bone_indexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_timeline,
              ffi.Int)>>('spine_translate_timeline_set_bone_index');
  late final _spine_translate_timeline_set_bone_index =
      _spine_translate_timeline_set_bone_indexPtr
          .asFunction<void Function(spine_translate_timeline, int)>();

  spine_rtti spine_translate_timeline_rtti() {
    return _spine_translate_timeline_rtti();
  }

  late final _spine_translate_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_translate_timeline_rtti');
  late final _spine_translate_timeline_rtti =
      _spine_translate_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_translate_x_timeline spine_translate_x_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_translate_x_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_translate_x_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_translate_x_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_translate_x_timeline_create');
  late final _spine_translate_x_timeline_create =
      _spine_translate_x_timeline_createPtr
          .asFunction<spine_translate_x_timeline Function(int, int, int)>();

  void spine_translate_x_timeline_dispose(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_dispose(
      self,
    );
  }

  late final _spine_translate_x_timeline_disposePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_translate_x_timeline)>>(
      'spine_translate_x_timeline_dispose');
  late final _spine_translate_x_timeline_dispose =
      _spine_translate_x_timeline_disposePtr
          .asFunction<void Function(spine_translate_x_timeline)>();

  spine_rtti spine_translate_x_timeline_get_rtti(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_rtti(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_translate_x_timeline)>>(
      'spine_translate_x_timeline_get_rtti');
  late final _spine_translate_x_timeline_get_rtti =
      _spine_translate_x_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_translate_x_timeline)>();

  void spine_translate_x_timeline_apply(
    spine_translate_x_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_translate_x_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_translate_x_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_translate_x_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_translate_x_timeline_apply');
  late final _spine_translate_x_timeline_apply =
      _spine_translate_x_timeline_applyPtr.asFunction<
          void Function(spine_translate_x_timeline, spine_skeleton, double,
              double, spine_array_event, double, int, int, bool)>();

  void spine_translate_x_timeline_set_frame(
    spine_translate_x_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_translate_x_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_translate_x_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_x_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_translate_x_timeline_set_frame');
  late final _spine_translate_x_timeline_set_frame =
      _spine_translate_x_timeline_set_framePtr.asFunction<
          void Function(spine_translate_x_timeline, int, double, double)>();

  double spine_translate_x_timeline_get_curve_value(
    spine_translate_x_timeline self,
    double time,
  ) {
    return _spine_translate_x_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_translate_x_timeline_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_translate_x_timeline,
              ffi.Float)>>('spine_translate_x_timeline_get_curve_value');
  late final _spine_translate_x_timeline_get_curve_value =
      _spine_translate_x_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_translate_x_timeline, double)>();

  double spine_translate_x_timeline_get_relative_value(
    spine_translate_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_translate_x_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_translate_x_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_translate_x_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_translate_x_timeline_get_relative_value');
  late final _spine_translate_x_timeline_get_relative_value =
      _spine_translate_x_timeline_get_relative_valuePtr.asFunction<
          double Function(spine_translate_x_timeline, double, double, int,
              double, double)>();

  double spine_translate_x_timeline_get_absolute_value_1(
    spine_translate_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_translate_x_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_translate_x_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_translate_x_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_translate_x_timeline_get_absolute_value_1');
  late final _spine_translate_x_timeline_get_absolute_value_1 =
      _spine_translate_x_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(spine_translate_x_timeline, double, double, int,
              double, double)>();

  double spine_translate_x_timeline_get_absolute_value_2(
    spine_translate_x_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_translate_x_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_translate_x_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_translate_x_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_translate_x_timeline_get_absolute_value_2');
  late final _spine_translate_x_timeline_get_absolute_value_2 =
      _spine_translate_x_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_translate_x_timeline, double, double, int,
              double, double, double)>();

  double spine_translate_x_timeline_get_scale_value(
    spine_translate_x_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_translate_x_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_translate_x_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_translate_x_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_translate_x_timeline_get_scale_value');
  late final _spine_translate_x_timeline_get_scale_value =
      _spine_translate_x_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_translate_x_timeline, double, double, int, int,
              double, double)>();

  void spine_translate_x_timeline_set_linear(
    spine_translate_x_timeline self,
    int frame,
  ) {
    return _spine_translate_x_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_translate_x_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_x_timeline,
              ffi.Size)>>('spine_translate_x_timeline_set_linear');
  late final _spine_translate_x_timeline_set_linear =
      _spine_translate_x_timeline_set_linearPtr
          .asFunction<void Function(spine_translate_x_timeline, int)>();

  void spine_translate_x_timeline_set_stepped(
    spine_translate_x_timeline self,
    int frame,
  ) {
    return _spine_translate_x_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_translate_x_timeline_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_x_timeline,
              ffi.Size)>>('spine_translate_x_timeline_set_stepped');
  late final _spine_translate_x_timeline_set_stepped =
      _spine_translate_x_timeline_set_steppedPtr
          .asFunction<void Function(spine_translate_x_timeline, int)>();

  void spine_translate_x_timeline_set_bezier(
    spine_translate_x_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_translate_x_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_translate_x_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_translate_x_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_translate_x_timeline_set_bezier');
  late final _spine_translate_x_timeline_set_bezier =
      _spine_translate_x_timeline_set_bezierPtr.asFunction<
          void Function(spine_translate_x_timeline, int, int, double, double,
              double, double, double, double, double, double, double)>();

  double spine_translate_x_timeline_get_bezier_value(
    spine_translate_x_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_translate_x_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_translate_x_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_translate_x_timeline,
              ffi.Float,
              ffi.Size,
              ffi.Size,
              ffi.Size)>>('spine_translate_x_timeline_get_bezier_value');
  late final _spine_translate_x_timeline_get_bezier_value =
      _spine_translate_x_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_translate_x_timeline, double, int, int, int)>();

  spine_array_float spine_translate_x_timeline_get_curves(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_curves(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_translate_x_timeline)>>(
      'spine_translate_x_timeline_get_curves');
  late final _spine_translate_x_timeline_get_curves =
      _spine_translate_x_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_translate_x_timeline)>();

  int spine_translate_x_timeline_get_frame_entries(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_frame_entriesPtr = _lookup<
          ffi.NativeFunction<ffi.Size Function(spine_translate_x_timeline)>>(
      'spine_translate_x_timeline_get_frame_entries');
  late final _spine_translate_x_timeline_get_frame_entries =
      _spine_translate_x_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_translate_x_timeline)>();

  int spine_translate_x_timeline_get_frame_count(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_frame_countPtr = _lookup<
          ffi.NativeFunction<ffi.Size Function(spine_translate_x_timeline)>>(
      'spine_translate_x_timeline_get_frame_count');
  late final _spine_translate_x_timeline_get_frame_count =
      _spine_translate_x_timeline_get_frame_countPtr
          .asFunction<int Function(spine_translate_x_timeline)>();

  spine_array_float spine_translate_x_timeline_get_frames(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_frames(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_translate_x_timeline)>>(
      'spine_translate_x_timeline_get_frames');
  late final _spine_translate_x_timeline_get_frames =
      _spine_translate_x_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_translate_x_timeline)>();

  double spine_translate_x_timeline_get_duration(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_duration(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_translate_x_timeline)>>(
      'spine_translate_x_timeline_get_duration');
  late final _spine_translate_x_timeline_get_duration =
      _spine_translate_x_timeline_get_durationPtr
          .asFunction<double Function(spine_translate_x_timeline)>();

  spine_array_property_id spine_translate_x_timeline_get_property_ids(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_translate_x_timeline)>>(
      'spine_translate_x_timeline_get_property_ids');
  late final _spine_translate_x_timeline_get_property_ids =
      _spine_translate_x_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_translate_x_timeline)>();

  int spine_translate_x_timeline_get_bone_index(
    spine_translate_x_timeline self,
  ) {
    return _spine_translate_x_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_translate_x_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_translate_x_timeline)>>(
          'spine_translate_x_timeline_get_bone_index');
  late final _spine_translate_x_timeline_get_bone_index =
      _spine_translate_x_timeline_get_bone_indexPtr
          .asFunction<int Function(spine_translate_x_timeline)>();

  void spine_translate_x_timeline_set_bone_index(
    spine_translate_x_timeline self,
    int inValue,
  ) {
    return _spine_translate_x_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_translate_x_timeline_set_bone_indexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_x_timeline,
              ffi.Int)>>('spine_translate_x_timeline_set_bone_index');
  late final _spine_translate_x_timeline_set_bone_index =
      _spine_translate_x_timeline_set_bone_indexPtr
          .asFunction<void Function(spine_translate_x_timeline, int)>();

  spine_rtti spine_translate_x_timeline_rtti() {
    return _spine_translate_x_timeline_rtti();
  }

  late final _spine_translate_x_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_translate_x_timeline_rtti');
  late final _spine_translate_x_timeline_rtti =
      _spine_translate_x_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  spine_translate_y_timeline spine_translate_y_timeline_create(
    int frameCount,
    int bezierCount,
    int boneIndex,
  ) {
    return _spine_translate_y_timeline_create(
      frameCount,
      bezierCount,
      boneIndex,
    );
  }

  late final _spine_translate_y_timeline_createPtr = _lookup<
      ffi.NativeFunction<
          spine_translate_y_timeline Function(ffi.Size, ffi.Size,
              ffi.Int)>>('spine_translate_y_timeline_create');
  late final _spine_translate_y_timeline_create =
      _spine_translate_y_timeline_createPtr
          .asFunction<spine_translate_y_timeline Function(int, int, int)>();

  void spine_translate_y_timeline_dispose(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_dispose(
      self,
    );
  }

  late final _spine_translate_y_timeline_disposePtr = _lookup<
          ffi.NativeFunction<ffi.Void Function(spine_translate_y_timeline)>>(
      'spine_translate_y_timeline_dispose');
  late final _spine_translate_y_timeline_dispose =
      _spine_translate_y_timeline_disposePtr
          .asFunction<void Function(spine_translate_y_timeline)>();

  spine_rtti spine_translate_y_timeline_get_rtti(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_rtti(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_rttiPtr = _lookup<
          ffi.NativeFunction<spine_rtti Function(spine_translate_y_timeline)>>(
      'spine_translate_y_timeline_get_rtti');
  late final _spine_translate_y_timeline_get_rtti =
      _spine_translate_y_timeline_get_rttiPtr
          .asFunction<spine_rtti Function(spine_translate_y_timeline)>();

  void spine_translate_y_timeline_apply(
    spine_translate_y_timeline self,
    spine_skeleton skeleton,
    double lastTime,
    double time,
    spine_array_event pEvents,
    double alpha,
    int blend,
    int direction,
    bool appliedPose,
  ) {
    return _spine_translate_y_timeline_apply(
      self,
      skeleton,
      lastTime,
      time,
      pEvents,
      alpha,
      blend,
      direction,
      appliedPose,
    );
  }

  late final _spine_translate_y_timeline_applyPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_translate_y_timeline,
              spine_skeleton,
              ffi.Float,
              ffi.Float,
              spine_array_event,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Bool)>>('spine_translate_y_timeline_apply');
  late final _spine_translate_y_timeline_apply =
      _spine_translate_y_timeline_applyPtr.asFunction<
          void Function(spine_translate_y_timeline, spine_skeleton, double,
              double, spine_array_event, double, int, int, bool)>();

  void spine_translate_y_timeline_set_frame(
    spine_translate_y_timeline self,
    int frame,
    double time,
    double value,
  ) {
    return _spine_translate_y_timeline_set_frame(
      self,
      frame,
      time,
      value,
    );
  }

  late final _spine_translate_y_timeline_set_framePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_y_timeline, ffi.Size, ffi.Float,
              ffi.Float)>>('spine_translate_y_timeline_set_frame');
  late final _spine_translate_y_timeline_set_frame =
      _spine_translate_y_timeline_set_framePtr.asFunction<
          void Function(spine_translate_y_timeline, int, double, double)>();

  double spine_translate_y_timeline_get_curve_value(
    spine_translate_y_timeline self,
    double time,
  ) {
    return _spine_translate_y_timeline_get_curve_value(
      self,
      time,
    );
  }

  late final _spine_translate_y_timeline_get_curve_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(spine_translate_y_timeline,
              ffi.Float)>>('spine_translate_y_timeline_get_curve_value');
  late final _spine_translate_y_timeline_get_curve_value =
      _spine_translate_y_timeline_get_curve_valuePtr
          .asFunction<double Function(spine_translate_y_timeline, double)>();

  double spine_translate_y_timeline_get_relative_value(
    spine_translate_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_translate_y_timeline_get_relative_value(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_translate_y_timeline_get_relative_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_translate_y_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_translate_y_timeline_get_relative_value');
  late final _spine_translate_y_timeline_get_relative_value =
      _spine_translate_y_timeline_get_relative_valuePtr.asFunction<
          double Function(spine_translate_y_timeline, double, double, int,
              double, double)>();

  double spine_translate_y_timeline_get_absolute_value_1(
    spine_translate_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
  ) {
    return _spine_translate_y_timeline_get_absolute_value_1(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
    );
  }

  late final _spine_translate_y_timeline_get_absolute_value_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_translate_y_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_translate_y_timeline_get_absolute_value_1');
  late final _spine_translate_y_timeline_get_absolute_value_1 =
      _spine_translate_y_timeline_get_absolute_value_1Ptr.asFunction<
          double Function(spine_translate_y_timeline, double, double, int,
              double, double)>();

  double spine_translate_y_timeline_get_absolute_value_2(
    spine_translate_y_timeline self,
    double time,
    double alpha,
    int blend,
    double current,
    double setup,
    double value,
  ) {
    return _spine_translate_y_timeline_get_absolute_value_2(
      self,
      time,
      alpha,
      blend,
      current,
      setup,
      value,
    );
  }

  late final _spine_translate_y_timeline_get_absolute_value_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_translate_y_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_translate_y_timeline_get_absolute_value_2');
  late final _spine_translate_y_timeline_get_absolute_value_2 =
      _spine_translate_y_timeline_get_absolute_value_2Ptr.asFunction<
          double Function(spine_translate_y_timeline, double, double, int,
              double, double, double)>();

  double spine_translate_y_timeline_get_scale_value(
    spine_translate_y_timeline self,
    double time,
    double alpha,
    int blend,
    int direction,
    double current,
    double setup,
  ) {
    return _spine_translate_y_timeline_get_scale_value(
      self,
      time,
      alpha,
      blend,
      direction,
      current,
      setup,
    );
  }

  late final _spine_translate_y_timeline_get_scale_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_translate_y_timeline,
              ffi.Float,
              ffi.Float,
              ffi.Int32,
              ffi.Int32,
              ffi.Float,
              ffi.Float)>>('spine_translate_y_timeline_get_scale_value');
  late final _spine_translate_y_timeline_get_scale_value =
      _spine_translate_y_timeline_get_scale_valuePtr.asFunction<
          double Function(spine_translate_y_timeline, double, double, int, int,
              double, double)>();

  void spine_translate_y_timeline_set_linear(
    spine_translate_y_timeline self,
    int frame,
  ) {
    return _spine_translate_y_timeline_set_linear(
      self,
      frame,
    );
  }

  late final _spine_translate_y_timeline_set_linearPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_y_timeline,
              ffi.Size)>>('spine_translate_y_timeline_set_linear');
  late final _spine_translate_y_timeline_set_linear =
      _spine_translate_y_timeline_set_linearPtr
          .asFunction<void Function(spine_translate_y_timeline, int)>();

  void spine_translate_y_timeline_set_stepped(
    spine_translate_y_timeline self,
    int frame,
  ) {
    return _spine_translate_y_timeline_set_stepped(
      self,
      frame,
    );
  }

  late final _spine_translate_y_timeline_set_steppedPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_y_timeline,
              ffi.Size)>>('spine_translate_y_timeline_set_stepped');
  late final _spine_translate_y_timeline_set_stepped =
      _spine_translate_y_timeline_set_steppedPtr
          .asFunction<void Function(spine_translate_y_timeline, int)>();

  void spine_translate_y_timeline_set_bezier(
    spine_translate_y_timeline self,
    int bezier,
    int frame,
    double value,
    double time1,
    double value1,
    double cx1,
    double cy1,
    double cx2,
    double cy2,
    double time2,
    double value2,
  ) {
    return _spine_translate_y_timeline_set_bezier(
      self,
      bezier,
      frame,
      value,
      time1,
      value1,
      cx1,
      cy1,
      cx2,
      cy2,
      time2,
      value2,
    );
  }

  late final _spine_translate_y_timeline_set_bezierPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_translate_y_timeline,
              ffi.Size,
              ffi.Size,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float,
              ffi.Float)>>('spine_translate_y_timeline_set_bezier');
  late final _spine_translate_y_timeline_set_bezier =
      _spine_translate_y_timeline_set_bezierPtr.asFunction<
          void Function(spine_translate_y_timeline, int, int, double, double,
              double, double, double, double, double, double, double)>();

  double spine_translate_y_timeline_get_bezier_value(
    spine_translate_y_timeline self,
    double time,
    int frame,
    int valueOffset,
    int i,
  ) {
    return _spine_translate_y_timeline_get_bezier_value(
      self,
      time,
      frame,
      valueOffset,
      i,
    );
  }

  late final _spine_translate_y_timeline_get_bezier_valuePtr = _lookup<
      ffi.NativeFunction<
          ffi.Float Function(
              spine_translate_y_timeline,
              ffi.Float,
              ffi.Size,
              ffi.Size,
              ffi.Size)>>('spine_translate_y_timeline_get_bezier_value');
  late final _spine_translate_y_timeline_get_bezier_value =
      _spine_translate_y_timeline_get_bezier_valuePtr.asFunction<
          double Function(spine_translate_y_timeline, double, int, int, int)>();

  spine_array_float spine_translate_y_timeline_get_curves(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_curves(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_curvesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_translate_y_timeline)>>(
      'spine_translate_y_timeline_get_curves');
  late final _spine_translate_y_timeline_get_curves =
      _spine_translate_y_timeline_get_curvesPtr
          .asFunction<spine_array_float Function(spine_translate_y_timeline)>();

  int spine_translate_y_timeline_get_frame_entries(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_frame_entries(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_frame_entriesPtr = _lookup<
          ffi.NativeFunction<ffi.Size Function(spine_translate_y_timeline)>>(
      'spine_translate_y_timeline_get_frame_entries');
  late final _spine_translate_y_timeline_get_frame_entries =
      _spine_translate_y_timeline_get_frame_entriesPtr
          .asFunction<int Function(spine_translate_y_timeline)>();

  int spine_translate_y_timeline_get_frame_count(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_frame_count(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_frame_countPtr = _lookup<
          ffi.NativeFunction<ffi.Size Function(spine_translate_y_timeline)>>(
      'spine_translate_y_timeline_get_frame_count');
  late final _spine_translate_y_timeline_get_frame_count =
      _spine_translate_y_timeline_get_frame_countPtr
          .asFunction<int Function(spine_translate_y_timeline)>();

  spine_array_float spine_translate_y_timeline_get_frames(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_frames(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_framesPtr = _lookup<
          ffi.NativeFunction<
              spine_array_float Function(spine_translate_y_timeline)>>(
      'spine_translate_y_timeline_get_frames');
  late final _spine_translate_y_timeline_get_frames =
      _spine_translate_y_timeline_get_framesPtr
          .asFunction<spine_array_float Function(spine_translate_y_timeline)>();

  double spine_translate_y_timeline_get_duration(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_duration(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_durationPtr = _lookup<
          ffi.NativeFunction<ffi.Float Function(spine_translate_y_timeline)>>(
      'spine_translate_y_timeline_get_duration');
  late final _spine_translate_y_timeline_get_duration =
      _spine_translate_y_timeline_get_durationPtr
          .asFunction<double Function(spine_translate_y_timeline)>();

  spine_array_property_id spine_translate_y_timeline_get_property_ids(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_property_ids(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_property_idsPtr = _lookup<
          ffi.NativeFunction<
              spine_array_property_id Function(spine_translate_y_timeline)>>(
      'spine_translate_y_timeline_get_property_ids');
  late final _spine_translate_y_timeline_get_property_ids =
      _spine_translate_y_timeline_get_property_idsPtr.asFunction<
          spine_array_property_id Function(spine_translate_y_timeline)>();

  int spine_translate_y_timeline_get_bone_index(
    spine_translate_y_timeline self,
  ) {
    return _spine_translate_y_timeline_get_bone_index(
      self,
    );
  }

  late final _spine_translate_y_timeline_get_bone_indexPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_translate_y_timeline)>>(
          'spine_translate_y_timeline_get_bone_index');
  late final _spine_translate_y_timeline_get_bone_index =
      _spine_translate_y_timeline_get_bone_indexPtr
          .asFunction<int Function(spine_translate_y_timeline)>();

  void spine_translate_y_timeline_set_bone_index(
    spine_translate_y_timeline self,
    int inValue,
  ) {
    return _spine_translate_y_timeline_set_bone_index(
      self,
      inValue,
    );
  }

  late final _spine_translate_y_timeline_set_bone_indexPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_translate_y_timeline,
              ffi.Int)>>('spine_translate_y_timeline_set_bone_index');
  late final _spine_translate_y_timeline_set_bone_index =
      _spine_translate_y_timeline_set_bone_indexPtr
          .asFunction<void Function(spine_translate_y_timeline, int)>();

  spine_rtti spine_translate_y_timeline_rtti() {
    return _spine_translate_y_timeline_rtti();
  }

  late final _spine_translate_y_timeline_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_translate_y_timeline_rtti');
  late final _spine_translate_y_timeline_rtti =
      _spine_translate_y_timeline_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_update_dispose(
    spine_update self,
  ) {
    return _spine_update_dispose(
      self,
    );
  }

  late final _spine_update_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_update)>>(
          'spine_update_dispose');
  late final _spine_update_dispose =
      _spine_update_disposePtr.asFunction<void Function(spine_update)>();

  spine_rtti spine_update_get_rtti(
    spine_update self,
  ) {
    return _spine_update_get_rtti(
      self,
    );
  }

  late final _spine_update_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_update)>>(
          'spine_update_get_rtti');
  late final _spine_update_get_rtti =
      _spine_update_get_rttiPtr.asFunction<spine_rtti Function(spine_update)>();

  void spine_update_update(
    spine_update self,
    spine_skeleton skeleton,
    int physics,
  ) {
    return _spine_update_update(
      self,
      skeleton,
      physics,
    );
  }

  late final _spine_update_updatePtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_update, spine_skeleton, ffi.Int32)>>('spine_update_update');
  late final _spine_update_update = _spine_update_updatePtr
      .asFunction<void Function(spine_update, spine_skeleton, int)>();

  spine_rtti spine_update_rtti() {
    return _spine_update_rtti();
  }

  late final _spine_update_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>('spine_update_rtti');
  late final _spine_update_rtti =
      _spine_update_rttiPtr.asFunction<spine_rtti Function()>();

  void spine_vertex_attachment_dispose(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_dispose(
      self,
    );
  }

  late final _spine_vertex_attachment_disposePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_dispose');
  late final _spine_vertex_attachment_dispose =
      _spine_vertex_attachment_disposePtr
          .asFunction<void Function(spine_vertex_attachment)>();

  spine_rtti spine_vertex_attachment_get_rtti(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_rtti(
      self,
    );
  }

  late final _spine_vertex_attachment_get_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_get_rtti');
  late final _spine_vertex_attachment_get_rtti =
      _spine_vertex_attachment_get_rttiPtr
          .asFunction<spine_rtti Function(spine_vertex_attachment)>();

  void spine_vertex_attachment_compute_world_vertices_1(
    spine_vertex_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    ffi.Pointer<ffi.Float> worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_vertex_attachment_compute_world_vertices_1(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_vertex_attachment_compute_world_vertices_1Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_vertex_attachment,
              spine_skeleton,
              spine_slot,
              ffi.Size,
              ffi.Size,
              ffi.Pointer<ffi.Float>,
              ffi.Size,
              ffi.Size)>>('spine_vertex_attachment_compute_world_vertices_1');
  late final _spine_vertex_attachment_compute_world_vertices_1 =
      _spine_vertex_attachment_compute_world_vertices_1Ptr.asFunction<
          void Function(spine_vertex_attachment, spine_skeleton, spine_slot,
              int, int, ffi.Pointer<ffi.Float>, int, int)>();

  void spine_vertex_attachment_compute_world_vertices_2(
    spine_vertex_attachment self,
    spine_skeleton skeleton,
    spine_slot slot,
    int start,
    int count,
    spine_array_float worldVertices,
    int offset,
    int stride,
  ) {
    return _spine_vertex_attachment_compute_world_vertices_2(
      self,
      skeleton,
      slot,
      start,
      count,
      worldVertices,
      offset,
      stride,
    );
  }

  late final _spine_vertex_attachment_compute_world_vertices_2Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              spine_vertex_attachment,
              spine_skeleton,
              spine_slot,
              ffi.Size,
              ffi.Size,
              spine_array_float,
              ffi.Size,
              ffi.Size)>>('spine_vertex_attachment_compute_world_vertices_2');
  late final _spine_vertex_attachment_compute_world_vertices_2 =
      _spine_vertex_attachment_compute_world_vertices_2Ptr.asFunction<
          void Function(spine_vertex_attachment, spine_skeleton, spine_slot,
              int, int, spine_array_float, int, int)>();

  int spine_vertex_attachment_get_id(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_id(
      self,
    );
  }

  late final _spine_vertex_attachment_get_idPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_get_id');
  late final _spine_vertex_attachment_get_id =
      _spine_vertex_attachment_get_idPtr
          .asFunction<int Function(spine_vertex_attachment)>();

  spine_array_int spine_vertex_attachment_get_bones(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_bones(
      self,
    );
  }

  late final _spine_vertex_attachment_get_bonesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_int Function(spine_vertex_attachment)>>(
      'spine_vertex_attachment_get_bones');
  late final _spine_vertex_attachment_get_bones =
      _spine_vertex_attachment_get_bonesPtr
          .asFunction<spine_array_int Function(spine_vertex_attachment)>();

  void spine_vertex_attachment_set_bones(
    spine_vertex_attachment self,
    spine_array_int bones,
  ) {
    return _spine_vertex_attachment_set_bones(
      self,
      bones,
    );
  }

  late final _spine_vertex_attachment_set_bonesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_vertex_attachment,
              spine_array_int)>>('spine_vertex_attachment_set_bones');
  late final _spine_vertex_attachment_set_bones =
      _spine_vertex_attachment_set_bonesPtr.asFunction<
          void Function(spine_vertex_attachment, spine_array_int)>();

  spine_array_float spine_vertex_attachment_get_vertices(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_vertices(
      self,
    );
  }

  late final _spine_vertex_attachment_get_verticesPtr = _lookup<
          ffi
          .NativeFunction<spine_array_float Function(spine_vertex_attachment)>>(
      'spine_vertex_attachment_get_vertices');
  late final _spine_vertex_attachment_get_vertices =
      _spine_vertex_attachment_get_verticesPtr
          .asFunction<spine_array_float Function(spine_vertex_attachment)>();

  void spine_vertex_attachment_set_vertices(
    spine_vertex_attachment self,
    spine_array_float vertices,
  ) {
    return _spine_vertex_attachment_set_vertices(
      self,
      vertices,
    );
  }

  late final _spine_vertex_attachment_set_verticesPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_vertex_attachment,
              spine_array_float)>>('spine_vertex_attachment_set_vertices');
  late final _spine_vertex_attachment_set_vertices =
      _spine_vertex_attachment_set_verticesPtr.asFunction<
          void Function(spine_vertex_attachment, spine_array_float)>();

  int spine_vertex_attachment_get_world_vertices_length(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_world_vertices_length(
      self,
    );
  }

  late final _spine_vertex_attachment_get_world_vertices_lengthPtr =
      _lookup<ffi.NativeFunction<ffi.Size Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_get_world_vertices_length');
  late final _spine_vertex_attachment_get_world_vertices_length =
      _spine_vertex_attachment_get_world_vertices_lengthPtr
          .asFunction<int Function(spine_vertex_attachment)>();

  void spine_vertex_attachment_set_world_vertices_length(
    spine_vertex_attachment self,
    int inValue,
  ) {
    return _spine_vertex_attachment_set_world_vertices_length(
      self,
      inValue,
    );
  }

  late final _spine_vertex_attachment_set_world_vertices_lengthPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_vertex_attachment,
              ffi.Size)>>('spine_vertex_attachment_set_world_vertices_length');
  late final _spine_vertex_attachment_set_world_vertices_length =
      _spine_vertex_attachment_set_world_vertices_lengthPtr
          .asFunction<void Function(spine_vertex_attachment, int)>();

  spine_attachment spine_vertex_attachment_get_timeline_attachment(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_timeline_attachment(
      self,
    );
  }

  late final _spine_vertex_attachment_get_timeline_attachmentPtr = _lookup<
          ffi
          .NativeFunction<spine_attachment Function(spine_vertex_attachment)>>(
      'spine_vertex_attachment_get_timeline_attachment');
  late final _spine_vertex_attachment_get_timeline_attachment =
      _spine_vertex_attachment_get_timeline_attachmentPtr
          .asFunction<spine_attachment Function(spine_vertex_attachment)>();

  void spine_vertex_attachment_set_timeline_attachment(
    spine_vertex_attachment self,
    spine_attachment attachment,
  ) {
    return _spine_vertex_attachment_set_timeline_attachment(
      self,
      attachment,
    );
  }

  late final _spine_vertex_attachment_set_timeline_attachmentPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(spine_vertex_attachment, spine_attachment)>>(
      'spine_vertex_attachment_set_timeline_attachment');
  late final _spine_vertex_attachment_set_timeline_attachment =
      _spine_vertex_attachment_set_timeline_attachmentPtr.asFunction<
          void Function(spine_vertex_attachment, spine_attachment)>();

  void spine_vertex_attachment_copy_to(
    spine_vertex_attachment self,
    spine_vertex_attachment other,
  ) {
    return _spine_vertex_attachment_copy_to(
      self,
      other,
    );
  }

  late final _spine_vertex_attachment_copy_toPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(spine_vertex_attachment,
              spine_vertex_attachment)>>('spine_vertex_attachment_copy_to');
  late final _spine_vertex_attachment_copy_to =
      _spine_vertex_attachment_copy_toPtr.asFunction<
          void Function(spine_vertex_attachment, spine_vertex_attachment)>();

  ffi.Pointer<ffi.Char> spine_vertex_attachment_get_name(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_name(
      self,
    );
  }

  late final _spine_vertex_attachment_get_namePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Char> Function(
              spine_vertex_attachment)>>('spine_vertex_attachment_get_name');
  late final _spine_vertex_attachment_get_name =
      _spine_vertex_attachment_get_namePtr.asFunction<
          ffi.Pointer<ffi.Char> Function(spine_vertex_attachment)>();

  spine_attachment spine_vertex_attachment_copy(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_copy(
      self,
    );
  }

  late final _spine_vertex_attachment_copyPtr = _lookup<
          ffi
          .NativeFunction<spine_attachment Function(spine_vertex_attachment)>>(
      'spine_vertex_attachment_copy');
  late final _spine_vertex_attachment_copy = _spine_vertex_attachment_copyPtr
      .asFunction<spine_attachment Function(spine_vertex_attachment)>();

  int spine_vertex_attachment_get_ref_count(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_get_ref_count(
      self,
    );
  }

  late final _spine_vertex_attachment_get_ref_countPtr =
      _lookup<ffi.NativeFunction<ffi.Int Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_get_ref_count');
  late final _spine_vertex_attachment_get_ref_count =
      _spine_vertex_attachment_get_ref_countPtr
          .asFunction<int Function(spine_vertex_attachment)>();

  void spine_vertex_attachment_reference(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_reference(
      self,
    );
  }

  late final _spine_vertex_attachment_referencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_reference');
  late final _spine_vertex_attachment_reference =
      _spine_vertex_attachment_referencePtr
          .asFunction<void Function(spine_vertex_attachment)>();

  void spine_vertex_attachment_dereference(
    spine_vertex_attachment self,
  ) {
    return _spine_vertex_attachment_dereference(
      self,
    );
  }

  late final _spine_vertex_attachment_dereferencePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment)>>(
          'spine_vertex_attachment_dereference');
  late final _spine_vertex_attachment_dereference =
      _spine_vertex_attachment_dereferencePtr
          .asFunction<void Function(spine_vertex_attachment)>();

  spine_rtti spine_vertex_attachment_rtti() {
    return _spine_vertex_attachment_rtti();
  }

  late final _spine_vertex_attachment_rttiPtr =
      _lookup<ffi.NativeFunction<spine_rtti Function()>>(
          'spine_vertex_attachment_rtti');
  late final _spine_vertex_attachment_rtti =
      _spine_vertex_attachment_rttiPtr.asFunction<spine_rtti Function()>();
}

final class spine_skeleton_data_result_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_bounds_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_vector_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_skeleton_drawable_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_animation_state_events_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_skin_entry_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_skin_entries_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_texture_loader_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

typedef spine_bounds = ffi.Pointer<spine_bounds_wrapper>;
typedef spine_vector = ffi.Pointer<spine_vector_wrapper>;

/// Texture loader callbacks
typedef spine_texture_loader_load_func
    = ffi.Pointer<ffi.NativeFunction<spine_texture_loader_load_funcFunction>>;
typedef spine_texture_loader_load_funcFunction = ffi.Pointer<ffi.Void> Function(
    ffi.Pointer<ffi.Char> path);
typedef spine_texture_loader_unload_func
    = ffi.Pointer<ffi.NativeFunction<spine_texture_loader_unload_funcFunction>>;
typedef spine_texture_loader_unload_funcFunction = ffi.Void Function(
    ffi.Pointer<ffi.Void> texture);
typedef Dartspine_texture_loader_unload_funcFunction = void Function(
    ffi.Pointer<ffi.Void> texture);
typedef spine_skeleton_data_result
    = ffi.Pointer<spine_skeleton_data_result_wrapper>;
typedef spine_skeleton_drawable = ffi.Pointer<spine_skeleton_drawable_wrapper>;
typedef spine_animation_state_events
    = ffi.Pointer<spine_animation_state_events_wrapper>;
typedef spine_skin_entries = ffi.Pointer<spine_skin_entries_wrapper>;
typedef spine_skin_entry = ffi.Pointer<spine_skin_entry_wrapper>;

final class spine_alpha_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_animation_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_animation_state_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_animation_state_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_atlas_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_atlas_attachment_loader_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_atlas_page_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_atlas_region_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_attachment_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_attachment_loader_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_attachment_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_bone_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_bone_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_bone_local_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_bone_pose_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_bone_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_bone_timeline1_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_bone_timeline2_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_bounding_box_attachment_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_clipping_attachment_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_color_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_constraint_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_constraint_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_constraint_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_constraint_timeline1_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_curve_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_curve_timeline1_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_curve_timeline2_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_deform_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_draw_order_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_event_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_event_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_event_queue_entry_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_event_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_from_property_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_from_rotate_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_from_scale_x_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_from_scale_y_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_from_shear_y_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_from_x_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_from_y_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_ik_constraint_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_ik_constraint_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_ik_constraint_pose_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_ik_constraint_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_inherit_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_linked_mesh_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_mesh_attachment_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_path_attachment_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_path_constraint_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_path_constraint_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_path_constraint_mix_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_path_constraint_pose_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_path_constraint_position_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_path_constraint_spacing_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_physics_constraint_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_physics_constraint_damping_timeline_wrapper
    extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_physics_constraint_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_physics_constraint_gravity_timeline_wrapper
    extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_physics_constraint_inertia_timeline_wrapper
    extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_physics_constraint_mass_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_physics_constraint_mix_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_physics_constraint_pose_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_physics_constraint_reset_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_physics_constraint_strength_timeline_wrapper
    extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_physics_constraint_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_physics_constraint_wind_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_point_attachment_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_polygon_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_posed_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_posed_active_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_posed_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_region_attachment_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_render_command_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_rgb2_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_rgba2_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_rgba_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_rgb_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_rotate_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_rtti_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_scale_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_scale_x_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_scale_y_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_sequence_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_sequence_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_shear_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_shear_x_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_shear_y_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_skeleton_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_skeleton_binary_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_skeleton_bounds_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_skeleton_clipping_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_skeleton_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_skeleton_json_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_skeleton_renderer_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_skin_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_slider_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_slider_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_slider_mix_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_slider_pose_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_slider_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_slot_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_slot_curve_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_slot_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_slot_pose_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_slot_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_texture_region_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_to_property_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_to_rotate_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_to_scale_x_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_to_scale_y_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_to_shear_y_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_to_x_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_to_y_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_track_entry_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_transform_constraint_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_transform_constraint_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_transform_constraint_pose_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_transform_constraint_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_translate_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_translate_x_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_translate_y_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_update_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_vertex_attachment_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

abstract class spine_attachment_type {
  static const int SPINE_ATTACHMENT_TYPE_REGION = 0;
  static const int SPINE_ATTACHMENT_TYPE_BOUNDINGBOX = 1;
  static const int SPINE_ATTACHMENT_TYPE_MESH = 2;
  static const int SPINE_ATTACHMENT_TYPE_LINKEDMESH = 3;
  static const int SPINE_ATTACHMENT_TYPE_PATH = 4;
  static const int SPINE_ATTACHMENT_TYPE_POINT = 5;
  static const int SPINE_ATTACHMENT_TYPE_CLIPPING = 6;
}

abstract class spine_blend_mode {
  static const int SPINE_BLEND_MODE_NORMAL = 0;
  static const int SPINE_BLEND_MODE_ADDITIVE = 1;
  static const int SPINE_BLEND_MODE_MULTIPLY = 2;
  static const int SPINE_BLEND_MODE_SCREEN = 3;
}

abstract class spine_event_type {
  static const int SPINE_EVENT_TYPE_START = 0;
  static const int SPINE_EVENT_TYPE_INTERRUPT = 1;
  static const int SPINE_EVENT_TYPE_END = 2;
  static const int SPINE_EVENT_TYPE_DISPOSE = 3;
  static const int SPINE_EVENT_TYPE_COMPLETE = 4;
  static const int SPINE_EVENT_TYPE_EVENT = 5;
}

abstract class spine_format {
  static const int SPINE_FORMAT_ALPHA = 0;
  static const int SPINE_FORMAT_INTENSITY = 1;
  static const int SPINE_FORMAT_LUMINANCE_ALPHA = 2;
  static const int SPINE_FORMAT_RGB565 = 3;
  static const int SPINE_FORMAT_RGBA4444 = 4;
  static const int SPINE_FORMAT_RGB888 = 5;
  static const int SPINE_FORMAT_RGBA8888 = 6;
}

abstract class spine_inherit {
  static const int SPINE_INHERIT_NORMAL = 0;
  static const int SPINE_INHERIT_ONLY_TRANSLATION = 1;
  static const int SPINE_INHERIT_NO_ROTATION_OR_REFLECTION = 2;
  static const int SPINE_INHERIT_NO_SCALE = 3;
  static const int SPINE_INHERIT_NO_SCALE_OR_REFLECTION = 4;
}

abstract class spine_mix_blend {
  static const int SPINE_MIX_BLEND_SETUP = 0;
  static const int SPINE_MIX_BLEND_FIRST = 1;
  static const int SPINE_MIX_BLEND_REPLACE = 2;
  static const int SPINE_MIX_BLEND_ADD = 3;
}

abstract class spine_mix_direction {
  static const int SPINE_MIX_DIRECTION_IN = 0;
  static const int SPINE_MIX_DIRECTION_OUT = 1;
}

abstract class spine_physics {
  static const int SPINE_PHYSICS_NONE = 0;
  static const int SPINE_PHYSICS_RESET = 1;
  static const int SPINE_PHYSICS_UPDATE = 2;
  static const int SPINE_PHYSICS_POSE = 3;
}

abstract class spine_position_mode {
  static const int SPINE_POSITION_MODE_FIXED = 0;
  static const int SPINE_POSITION_MODE_PERCENT = 1;
}

abstract class spine_property {
  static const int SPINE_PROPERTY_ROTATE = 1;
  static const int SPINE_PROPERTY_X = 2;
  static const int SPINE_PROPERTY_Y = 4;
  static const int SPINE_PROPERTY_SCALE_X = 8;
  static const int SPINE_PROPERTY_SCALE_Y = 16;
  static const int SPINE_PROPERTY_SHEAR_X = 32;
  static const int SPINE_PROPERTY_SHEAR_Y = 64;
  static const int SPINE_PROPERTY_INHERIT = 128;
  static const int SPINE_PROPERTY_RGB = 256;
  static const int SPINE_PROPERTY_ALPHA = 512;
  static const int SPINE_PROPERTY_RGB2 = 1024;
  static const int SPINE_PROPERTY_ATTACHMENT = 2048;
  static const int SPINE_PROPERTY_DEFORM = 4096;
  static const int SPINE_PROPERTY_EVENT = 8192;
  static const int SPINE_PROPERTY_DRAW_ORDER = 16384;
  static const int SPINE_PROPERTY_IK_CONSTRAINT = 32768;
  static const int SPINE_PROPERTY_TRANSFORM_CONSTRAINT = 65536;
  static const int SPINE_PROPERTY_PATH_CONSTRAINT_POSITION = 131072;
  static const int SPINE_PROPERTY_PATH_CONSTRAINT_SPACING = 262144;
  static const int SPINE_PROPERTY_PATH_CONSTRAINT_MIX = 524288;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_INERTIA = 1048576;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_STRENGTH = 2097152;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_DAMPING = 4194304;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_MASS = 8388608;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_WIND = 16777216;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_GRAVITY = 33554432;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_MIX = 67108864;
  static const int SPINE_PROPERTY_PHYSICS_CONSTRAINT_RESET = 134217728;
  static const int SPINE_PROPERTY_SEQUENCE = 268435456;
  static const int SPINE_PROPERTY_SLIDER_TIME = 536870912;
  static const int SPINE_PROPERTY_SLIDER_MIX = 1073741824;
}

abstract class spine_rotate_mode {
  static const int SPINE_ROTATE_MODE_TANGENT = 0;
  static const int SPINE_ROTATE_MODE_CHAIN = 1;
  static const int SPINE_ROTATE_MODE_CHAIN_SCALE = 2;
}

abstract class spine_sequence_mode {
  static const int SPINE_SEQUENCE_MODE_HOLD = 0;
  static const int SPINE_SEQUENCE_MODE_ONCE = 1;
  static const int SPINE_SEQUENCE_MODE_LOOP = 2;
  static const int SPINE_SEQUENCE_MODE_PINGPONG = 3;
  static const int SPINE_SEQUENCE_MODE_ONCE_REVERSE = 4;
  static const int SPINE_SEQUENCE_MODE_LOOP_REVERSE = 5;
  static const int SPINE_SEQUENCE_MODE_PINGPONG_REVERSE = 6;
}

abstract class spine_spacing_mode {
  static const int SPINE_SPACING_MODE_LENGTH = 0;
  static const int SPINE_SPACING_MODE_FIXED = 1;
  static const int SPINE_SPACING_MODE_PERCENT = 2;
  static const int SPINE_SPACING_MODE_PROPORTIONAL = 3;
}

abstract class spine_texture_filter {
  static const int SPINE_TEXTURE_FILTER_UNKNOWN = 0;
  static const int SPINE_TEXTURE_FILTER_NEAREST = 1;
  static const int SPINE_TEXTURE_FILTER_LINEAR = 2;
  static const int SPINE_TEXTURE_FILTER_MIP_MAP = 3;
  static const int SPINE_TEXTURE_FILTER_MIP_MAP_NEAREST_NEAREST = 4;
  static const int SPINE_TEXTURE_FILTER_MIP_MAP_LINEAR_NEAREST = 5;
  static const int SPINE_TEXTURE_FILTER_MIP_MAP_NEAREST_LINEAR = 6;
  static const int SPINE_TEXTURE_FILTER_MIP_MAP_LINEAR_LINEAR = 7;
}

abstract class spine_texture_wrap {
  static const int SPINE_TEXTURE_WRAP_MIRRORED_REPEAT = 0;
  static const int SPINE_TEXTURE_WRAP_CLAMP_TO_EDGE = 1;
  static const int SPINE_TEXTURE_WRAP_REPEAT = 2;
}

final class spine_array_float_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_int_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_unsigned_short_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_property_id_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_animation_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_atlas_page_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_atlas_region_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_attachment_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_bone_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_bone_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_bone_pose_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_bounding_box_attachment_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_constraint_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_constraint_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_event_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_event_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_from_property_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_physics_constraint_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_polygon_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_skin_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_slot_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_slot_data_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_texture_region_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_timeline_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_to_property_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_track_entry_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

final class spine_array_update_wrapper extends ffi.Struct {
  @ffi.Char()
  external int _dummy;
}

typedef spine_array_float = ffi.Pointer<spine_array_float_wrapper>;
typedef spine_array_int = ffi.Pointer<spine_array_int_wrapper>;
typedef spine_array_unsigned_short
    = ffi.Pointer<spine_array_unsigned_short_wrapper>;
typedef spine_array_property_id = ffi.Pointer<spine_array_property_id_wrapper>;
typedef spine_array_animation = ffi.Pointer<spine_array_animation_wrapper>;
typedef spine_animation = ffi.Pointer<spine_animation_wrapper>;
typedef spine_array_atlas_page = ffi.Pointer<spine_array_atlas_page_wrapper>;
typedef spine_atlas_page = ffi.Pointer<spine_atlas_page_wrapper>;
typedef spine_array_atlas_region
    = ffi.Pointer<spine_array_atlas_region_wrapper>;
typedef spine_atlas_region = ffi.Pointer<spine_atlas_region_wrapper>;
typedef spine_array_attachment = ffi.Pointer<spine_array_attachment_wrapper>;
typedef spine_attachment = ffi.Pointer<spine_attachment_wrapper>;
typedef spine_array_bone = ffi.Pointer<spine_array_bone_wrapper>;
typedef spine_bone = ffi.Pointer<spine_bone_wrapper>;
typedef spine_array_bone_data = ffi.Pointer<spine_array_bone_data_wrapper>;
typedef spine_bone_data = ffi.Pointer<spine_bone_data_wrapper>;
typedef spine_array_bone_pose = ffi.Pointer<spine_array_bone_pose_wrapper>;
typedef spine_bone_pose = ffi.Pointer<spine_bone_pose_wrapper>;
typedef spine_array_bounding_box_attachment
    = ffi.Pointer<spine_array_bounding_box_attachment_wrapper>;
typedef spine_bounding_box_attachment
    = ffi.Pointer<spine_bounding_box_attachment_wrapper>;
typedef spine_array_constraint = ffi.Pointer<spine_array_constraint_wrapper>;
typedef spine_constraint = ffi.Pointer<spine_constraint_wrapper>;
typedef spine_array_constraint_data
    = ffi.Pointer<spine_array_constraint_data_wrapper>;
typedef spine_constraint_data = ffi.Pointer<spine_constraint_data_wrapper>;
typedef spine_array_event = ffi.Pointer<spine_array_event_wrapper>;
typedef spine_event = ffi.Pointer<spine_event_wrapper>;
typedef spine_array_event_data = ffi.Pointer<spine_array_event_data_wrapper>;
typedef spine_event_data = ffi.Pointer<spine_event_data_wrapper>;
typedef spine_array_from_property
    = ffi.Pointer<spine_array_from_property_wrapper>;
typedef spine_from_property = ffi.Pointer<spine_from_property_wrapper>;
typedef spine_array_physics_constraint
    = ffi.Pointer<spine_array_physics_constraint_wrapper>;
typedef spine_physics_constraint
    = ffi.Pointer<spine_physics_constraint_wrapper>;
typedef spine_array_polygon = ffi.Pointer<spine_array_polygon_wrapper>;
typedef spine_polygon = ffi.Pointer<spine_polygon_wrapper>;
typedef spine_array_skin = ffi.Pointer<spine_array_skin_wrapper>;
typedef spine_skin = ffi.Pointer<spine_skin_wrapper>;
typedef spine_array_slot = ffi.Pointer<spine_array_slot_wrapper>;
typedef spine_slot = ffi.Pointer<spine_slot_wrapper>;
typedef spine_array_slot_data = ffi.Pointer<spine_array_slot_data_wrapper>;
typedef spine_slot_data = ffi.Pointer<spine_slot_data_wrapper>;
typedef spine_array_texture_region
    = ffi.Pointer<spine_array_texture_region_wrapper>;
typedef spine_texture_region = ffi.Pointer<spine_texture_region_wrapper>;
typedef spine_array_timeline = ffi.Pointer<spine_array_timeline_wrapper>;
typedef spine_timeline = ffi.Pointer<spine_timeline_wrapper>;
typedef spine_array_to_property = ffi.Pointer<spine_array_to_property_wrapper>;
typedef spine_to_property = ffi.Pointer<spine_to_property_wrapper>;
typedef spine_array_track_entry = ffi.Pointer<spine_array_track_entry_wrapper>;
typedef spine_track_entry = ffi.Pointer<spine_track_entry_wrapper>;
typedef spine_array_update = ffi.Pointer<spine_array_update_wrapper>;
typedef spine_update = ffi.Pointer<spine_update_wrapper>;
typedef spine_alpha_timeline = ffi.Pointer<spine_alpha_timeline_wrapper>;
typedef spine_rtti = ffi.Pointer<spine_rtti_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_skeleton_data = ffi.Pointer<spine_skeleton_data_wrapper>;
typedef spine_atlas = ffi.Pointer<spine_atlas_wrapper>;
typedef spine_atlas_attachment_loader
    = ffi.Pointer<spine_atlas_attachment_loader_wrapper>;
typedef spine_region_attachment = ffi.Pointer<spine_region_attachment_wrapper>;
typedef spine_sequence = ffi.Pointer<spine_sequence_wrapper>;
typedef spine_mesh_attachment = ffi.Pointer<spine_mesh_attachment_wrapper>;
typedef spine_path_attachment = ffi.Pointer<spine_path_attachment_wrapper>;
typedef spine_point_attachment = ffi.Pointer<spine_point_attachment_wrapper>;
typedef spine_clipping_attachment
    = ffi.Pointer<spine_clipping_attachment_wrapper>;
typedef spine_attachment_loader = ffi.Pointer<spine_attachment_loader_wrapper>;
typedef spine_attachment_timeline
    = ffi.Pointer<spine_attachment_timeline_wrapper>;
typedef spine_bone_local = ffi.Pointer<spine_bone_local_wrapper>;
typedef spine_color = ffi.Pointer<spine_color_wrapper>;
typedef spine_bone_timeline = ffi.Pointer<spine_bone_timeline_wrapper>;
typedef spine_bone_timeline1 = ffi.Pointer<spine_bone_timeline1_wrapper>;
typedef spine_bone_timeline2 = ffi.Pointer<spine_bone_timeline2_wrapper>;
typedef spine_vertex_attachment = ffi.Pointer<spine_vertex_attachment_wrapper>;
typedef spine_constraint_timeline
    = ffi.Pointer<spine_constraint_timeline_wrapper>;
typedef spine_constraint_timeline1
    = ffi.Pointer<spine_constraint_timeline1_wrapper>;
typedef spine_curve_timeline = ffi.Pointer<spine_curve_timeline_wrapper>;
typedef spine_curve_timeline1 = ffi.Pointer<spine_curve_timeline1_wrapper>;
typedef spine_curve_timeline2 = ffi.Pointer<spine_curve_timeline2_wrapper>;
typedef spine_deform_timeline = ffi.Pointer<spine_deform_timeline_wrapper>;
typedef spine_draw_order_timeline
    = ffi.Pointer<spine_draw_order_timeline_wrapper>;
typedef spine_event_queue_entry = ffi.Pointer<spine_event_queue_entry_wrapper>;
typedef spine_event_timeline = ffi.Pointer<spine_event_timeline_wrapper>;
typedef spine_from_rotate = ffi.Pointer<spine_from_rotate_wrapper>;
typedef spine_from_scale_x = ffi.Pointer<spine_from_scale_x_wrapper>;
typedef spine_from_scale_y = ffi.Pointer<spine_from_scale_y_wrapper>;
typedef spine_from_shear_y = ffi.Pointer<spine_from_shear_y_wrapper>;
typedef spine_from_x = ffi.Pointer<spine_from_x_wrapper>;
typedef spine_from_y = ffi.Pointer<spine_from_y_wrapper>;
typedef spine_ik_constraint = ffi.Pointer<spine_ik_constraint_wrapper>;
typedef spine_ik_constraint_data
    = ffi.Pointer<spine_ik_constraint_data_wrapper>;
typedef spine_ik_constraint_pose
    = ffi.Pointer<spine_ik_constraint_pose_wrapper>;
typedef spine_ik_constraint_timeline
    = ffi.Pointer<spine_ik_constraint_timeline_wrapper>;
typedef spine_inherit_timeline = ffi.Pointer<spine_inherit_timeline_wrapper>;
typedef spine_linked_mesh = ffi.Pointer<spine_linked_mesh_wrapper>;
typedef spine_path_constraint = ffi.Pointer<spine_path_constraint_wrapper>;
typedef spine_path_constraint_data
    = ffi.Pointer<spine_path_constraint_data_wrapper>;
typedef spine_path_constraint_pose
    = ffi.Pointer<spine_path_constraint_pose_wrapper>;
typedef spine_path_constraint_mix_timeline
    = ffi.Pointer<spine_path_constraint_mix_timeline_wrapper>;
typedef spine_path_constraint_position_timeline
    = ffi.Pointer<spine_path_constraint_position_timeline_wrapper>;
typedef spine_path_constraint_spacing_timeline
    = ffi.Pointer<spine_path_constraint_spacing_timeline_wrapper>;
typedef spine_physics_constraint_data
    = ffi.Pointer<spine_physics_constraint_data_wrapper>;
typedef spine_physics_constraint_pose
    = ffi.Pointer<spine_physics_constraint_pose_wrapper>;
typedef spine_physics_constraint_damping_timeline
    = ffi.Pointer<spine_physics_constraint_damping_timeline_wrapper>;
typedef spine_physics_constraint_gravity_timeline
    = ffi.Pointer<spine_physics_constraint_gravity_timeline_wrapper>;
typedef spine_physics_constraint_inertia_timeline
    = ffi.Pointer<spine_physics_constraint_inertia_timeline_wrapper>;
typedef spine_physics_constraint_mass_timeline
    = ffi.Pointer<spine_physics_constraint_mass_timeline_wrapper>;
typedef spine_physics_constraint_mix_timeline
    = ffi.Pointer<spine_physics_constraint_mix_timeline_wrapper>;
typedef spine_physics_constraint_reset_timeline
    = ffi.Pointer<spine_physics_constraint_reset_timeline_wrapper>;
typedef spine_physics_constraint_strength_timeline
    = ffi.Pointer<spine_physics_constraint_strength_timeline_wrapper>;
typedef spine_physics_constraint_timeline
    = ffi.Pointer<spine_physics_constraint_timeline_wrapper>;
typedef spine_physics_constraint_wind_timeline
    = ffi.Pointer<spine_physics_constraint_wind_timeline_wrapper>;
typedef spine_posed = ffi.Pointer<spine_posed_wrapper>;
typedef spine_posed_active = ffi.Pointer<spine_posed_active_wrapper>;
typedef spine_posed_data = ffi.Pointer<spine_posed_data_wrapper>;
typedef spine_render_command = ffi.Pointer<spine_render_command_wrapper>;
typedef spine_rgb2_timeline = ffi.Pointer<spine_rgb2_timeline_wrapper>;
typedef spine_rgb_timeline = ffi.Pointer<spine_rgb_timeline_wrapper>;
typedef spine_rgba2_timeline = ffi.Pointer<spine_rgba2_timeline_wrapper>;
typedef spine_rgba_timeline = ffi.Pointer<spine_rgba_timeline_wrapper>;
typedef spine_rotate_timeline = ffi.Pointer<spine_rotate_timeline_wrapper>;
typedef spine_scale_timeline = ffi.Pointer<spine_scale_timeline_wrapper>;
typedef spine_scale_x_timeline = ffi.Pointer<spine_scale_x_timeline_wrapper>;
typedef spine_scale_y_timeline = ffi.Pointer<spine_scale_y_timeline_wrapper>;
typedef spine_slot_pose = ffi.Pointer<spine_slot_pose_wrapper>;
typedef spine_sequence_timeline = ffi.Pointer<spine_sequence_timeline_wrapper>;
typedef spine_shear_timeline = ffi.Pointer<spine_shear_timeline_wrapper>;
typedef spine_shear_x_timeline = ffi.Pointer<spine_shear_x_timeline_wrapper>;
typedef spine_shear_y_timeline = ffi.Pointer<spine_shear_y_timeline_wrapper>;
typedef spine_skeleton_clipping = ffi.Pointer<spine_skeleton_clipping_wrapper>;
typedef spine_skeleton_binary = ffi.Pointer<spine_skeleton_binary_wrapper>;
typedef spine_skeleton_bounds = ffi.Pointer<spine_skeleton_bounds_wrapper>;
typedef spine_skeleton_json = ffi.Pointer<spine_skeleton_json_wrapper>;
typedef spine_skeleton_renderer = ffi.Pointer<spine_skeleton_renderer_wrapper>;
typedef spine_slider = ffi.Pointer<spine_slider_wrapper>;
typedef spine_slider_data = ffi.Pointer<spine_slider_data_wrapper>;
typedef spine_slider_pose = ffi.Pointer<spine_slider_pose_wrapper>;
typedef spine_slider_mix_timeline
    = ffi.Pointer<spine_slider_mix_timeline_wrapper>;
typedef spine_slider_timeline = ffi.Pointer<spine_slider_timeline_wrapper>;
typedef spine_slot_curve_timeline
    = ffi.Pointer<spine_slot_curve_timeline_wrapper>;
typedef spine_slot_timeline = ffi.Pointer<spine_slot_timeline_wrapper>;
typedef spine_transform_constraint_pose
    = ffi.Pointer<spine_transform_constraint_pose_wrapper>;
typedef spine_to_rotate = ffi.Pointer<spine_to_rotate_wrapper>;
typedef spine_to_scale_x = ffi.Pointer<spine_to_scale_x_wrapper>;
typedef spine_to_scale_y = ffi.Pointer<spine_to_scale_y_wrapper>;
typedef spine_to_shear_y = ffi.Pointer<spine_to_shear_y_wrapper>;
typedef spine_to_x = ffi.Pointer<spine_to_x_wrapper>;
typedef spine_to_y = ffi.Pointer<spine_to_y_wrapper>;
typedef spine_transform_constraint
    = ffi.Pointer<spine_transform_constraint_wrapper>;
typedef spine_transform_constraint_data
    = ffi.Pointer<spine_transform_constraint_data_wrapper>;
typedef spine_transform_constraint_timeline
    = ffi.Pointer<spine_transform_constraint_timeline_wrapper>;
typedef spine_translate_timeline
    = ffi.Pointer<spine_translate_timeline_wrapper>;
typedef spine_translate_x_timeline
    = ffi.Pointer<spine_translate_x_timeline_wrapper>;
typedef spine_translate_y_timeline
    = ffi.Pointer<spine_translate_y_timeline_wrapper>;