Fix Hive generator enum handling for ClickUp

hive_generator/lib/src/builder.dart

@@ -12,7 +12,7 @@ class AdapterField {
 }
 
 abstract class Builder {
-  final ClassElement cls;
+  final InterfaceElement cls;
   final List<AdapterField> getters;
   final List<AdapterField> setters;
 

hive_generator/lib/src/class_builder.dart

@@ -13,7 +13,7 @@ import 'type_helper.dart';
 
 class ClassBuilder extends Builder {
   ClassBuilder(
-    ClassElement cls,
+    InterfaceElement cls,
     List<AdapterField> getters,
     List<AdapterField> setters,
   ) : super(cls, getters, setters);

hive_generator/lib/src/enum_builder.dart

@@ -3,7 +3,7 @@ import 'package:hive_generator/src/builder.dart';
 import 'package:hive_generator/src/helper.dart';
 
 class EnumBuilder extends Builder {
-  EnumBuilder(ClassElement cls, List<AdapterField> getters)
+  EnumBuilder(InterfaceElement cls, List<AdapterField> getters)
       : super(cls, getters);
 
   @override

hive_generator/lib/src/type_adapter_generator.dart

@@ -36,7 +36,7 @@ class TypeAdapterGenerator extends GeneratorForAnnotation<HiveType> {
     var typeId = getTypeId(annotation);
 
     var adapterName = getAdapterName(cls.name, annotation);
-    var builder = cls.isDartCoreEnum
+    var builder = cls.kind == ElementKind.ENUM
         ? EnumBuilder(cls, getters)
         : ClassBuilder(cls, getters, setters);
 
@@ -68,14 +68,14 @@ class TypeAdapterGenerator extends GeneratorForAnnotation<HiveType> {
     ''';
   }
 
-  ClassElement getClass(Element element) {
+  InterfaceElement getClass(Element element) {
     check(element.kind == ElementKind.CLASS || element.kind == ElementKind.ENUM,
         'Only classes or enums are allowed to be annotated with @HiveType.');
 
-    return element as ClassElement;
+    return element as InterfaceElement;
   }
 
-  Set<String> getAllAccessorNames(ClassElement cls) {
+  Set<String> getAllAccessorNames(InterfaceElement cls) {
     var accessorNames = <String>{};
 
     var supertypes = cls.allSupertypes.map((it) => it.element);
@@ -94,7 +94,7 @@ class TypeAdapterGenerator extends GeneratorForAnnotation<HiveType> {
   }
 
   List<List<AdapterField>> getAccessors(
-      ClassElement cls, LibraryElement library) {
+      InterfaceElement cls, LibraryElement library) {
     var accessorNames = getAllAccessorNames(cls);
 
     var getters = <AdapterField>[];

hive_generator/test/type_adapter_generator_test.dart

@@ -1,6 +1,43 @@
+import 'package:analyzer/dart/element/element.dart';
 import 'package:hive_generator/src/type_adapter_generator.dart';
 import 'package:test/test.dart';
 
+// Mock enum element that simulates EnumElementImpl
+class MockEnumElement implements Element {
+  @override
+  ElementKind get kind => ElementKind.ENUM;
+
+  @override
+  String get name => 'TestEnum';
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+// Mock class element  
+class MockClassElement implements Element, InterfaceElement {
+  @override
+  ElementKind get kind => ElementKind.CLASS;
+
+  @override
+  String get name => 'TestClass';
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+// Mock interface element for enum
+class MockEnumInterfaceElement implements Element, InterfaceElement {
+  @override
+  ElementKind get kind => ElementKind.ENUM;
+
+  @override
+  String get name => 'TestEnum';
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
 void main() {
   group('generateName', () {
     test('.generateName()', () {
@@ -9,4 +46,27 @@ void main() {
           'SomeClassAdapter');
     });
   });
+
+  group('getClass', () {
+    final generator = TypeAdapterGenerator();
+
+    test('handles class elements correctly', () {
+      final classElement = MockClassElement();
+      final result = generator.getClass(classElement);
+      expect(result, isA<InterfaceElement>());
+    });
+
+    test('handles enum elements correctly now', () {
+      final enumElement = MockEnumInterfaceElement();
+      final result = generator.getClass(enumElement);
+      expect(result, isA<InterfaceElement>());
+    });
+
+    test('accepts enum elements based on ElementKind check', () {
+      final enumElement = MockEnumElement();
+      // This should not throw when checking the kind
+      expect(enumElement.kind, ElementKind.ENUM);
+      expect(enumElement.kind == ElementKind.CLASS || enumElement.kind == ElementKind.ENUM, isTrue);
+    });
+  });
 }