// ignore_for_file: unused_element, camel_case_types, non_constant_identifier_names

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

class init_dylib1 {
  /// Holds the symbol lookup function.
  final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
      _lookup;

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

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

  void test() {
    return _test1();
  }

  late final _testPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>('test');
  late final _test1 = _testPtr.asFunction<void Function()>();

  void _test() {
    return __test();
  }

  late final __testPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>('_test');
  late final __test = __testPtr.asFunction<void Function()>();

  void _c_test() {
    return __c_test();
  }

  late final __c_testPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>('_c_test');
  late final __c_test = __c_testPtr.asFunction<void Function()>();

  void _dart_test() {
    return __dart_test();
  }

  late final __dart_testPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>('_dart_test');
  late final __dart_test = __dart_testPtr.asFunction<void Function()>();

  void Test() {
    return _Test();
  }

  late final _TestPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function()>>('Test');
  late final _Test = _TestPtr.asFunction<void Function()>();
}

class _Test extends ffi.Struct {
  @ffi.Array.multi([2])
  external ffi.Array<ffi.Int8> array;
}

class ArrayHelperPrefixCollisionTest extends ffi.Opaque {}

abstract class _c_Test {}

abstract class init_dylib {}
