runable

lib/core/database/models/enums.g.dart

@@ -0,0 +1,517 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'enums.dart';
+
+// **************************************************************************
+// TypeAdapterGenerator
+// **************************************************************************
+
+class MemberTierAdapter extends TypeAdapter<MemberTier> {
+  @override
+  final typeId = 20;
+
+  @override
+  MemberTier read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return MemberTier.gold;
+      case 1:
+        return MemberTier.platinum;
+      case 2:
+        return MemberTier.diamond;
+      default:
+        return MemberTier.gold;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, MemberTier obj) {
+    switch (obj) {
+      case MemberTier.gold:
+        writer.writeByte(0);
+      case MemberTier.platinum:
+        writer.writeByte(1);
+      case MemberTier.diamond:
+        writer.writeByte(2);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is MemberTierAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class UserTypeAdapter extends TypeAdapter<UserType> {
+  @override
+  final typeId = 21;
+
+  @override
+  UserType read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return UserType.contractor;
+      case 1:
+        return UserType.architect;
+      case 2:
+        return UserType.distributor;
+      case 3:
+        return UserType.broker;
+      default:
+        return UserType.contractor;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, UserType obj) {
+    switch (obj) {
+      case UserType.contractor:
+        writer.writeByte(0);
+      case UserType.architect:
+        writer.writeByte(1);
+      case UserType.distributor:
+        writer.writeByte(2);
+      case UserType.broker:
+        writer.writeByte(3);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is UserTypeAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class OrderStatusAdapter extends TypeAdapter<OrderStatus> {
+  @override
+  final typeId = 22;
+
+  @override
+  OrderStatus read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return OrderStatus.pending;
+      case 1:
+        return OrderStatus.processing;
+      case 2:
+        return OrderStatus.shipping;
+      case 3:
+        return OrderStatus.completed;
+      case 4:
+        return OrderStatus.cancelled;
+      case 5:
+        return OrderStatus.refunded;
+      default:
+        return OrderStatus.pending;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, OrderStatus obj) {
+    switch (obj) {
+      case OrderStatus.pending:
+        writer.writeByte(0);
+      case OrderStatus.processing:
+        writer.writeByte(1);
+      case OrderStatus.shipping:
+        writer.writeByte(2);
+      case OrderStatus.completed:
+        writer.writeByte(3);
+      case OrderStatus.cancelled:
+        writer.writeByte(4);
+      case OrderStatus.refunded:
+        writer.writeByte(5);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is OrderStatusAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class ProjectStatusAdapter extends TypeAdapter<ProjectStatus> {
+  @override
+  final typeId = 23;
+
+  @override
+  ProjectStatus read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return ProjectStatus.planning;
+      case 1:
+        return ProjectStatus.inProgress;
+      case 2:
+        return ProjectStatus.onHold;
+      case 3:
+        return ProjectStatus.completed;
+      case 4:
+        return ProjectStatus.cancelled;
+      default:
+        return ProjectStatus.planning;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, ProjectStatus obj) {
+    switch (obj) {
+      case ProjectStatus.planning:
+        writer.writeByte(0);
+      case ProjectStatus.inProgress:
+        writer.writeByte(1);
+      case ProjectStatus.onHold:
+        writer.writeByte(2);
+      case ProjectStatus.completed:
+        writer.writeByte(3);
+      case ProjectStatus.cancelled:
+        writer.writeByte(4);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is ProjectStatusAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class ProjectTypeAdapter extends TypeAdapter<ProjectType> {
+  @override
+  final typeId = 24;
+
+  @override
+  ProjectType read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return ProjectType.residential;
+      case 1:
+        return ProjectType.commercial;
+      case 2:
+        return ProjectType.industrial;
+      case 3:
+        return ProjectType.infrastructure;
+      case 4:
+        return ProjectType.renovation;
+      default:
+        return ProjectType.residential;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, ProjectType obj) {
+    switch (obj) {
+      case ProjectType.residential:
+        writer.writeByte(0);
+      case ProjectType.commercial:
+        writer.writeByte(1);
+      case ProjectType.industrial:
+        writer.writeByte(2);
+      case ProjectType.infrastructure:
+        writer.writeByte(3);
+      case ProjectType.renovation:
+        writer.writeByte(4);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is ProjectTypeAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class TransactionTypeAdapter extends TypeAdapter<TransactionType> {
+  @override
+  final typeId = 25;
+
+  @override
+  TransactionType read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return TransactionType.earnedPurchase;
+      case 1:
+        return TransactionType.earnedReferral;
+      case 2:
+        return TransactionType.earnedPromotion;
+      case 3:
+        return TransactionType.earnedBonus;
+      case 4:
+        return TransactionType.redeemedReward;
+      case 5:
+        return TransactionType.redeemedDiscount;
+      case 6:
+        return TransactionType.adjustment;
+      case 7:
+        return TransactionType.expired;
+      default:
+        return TransactionType.earnedPurchase;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, TransactionType obj) {
+    switch (obj) {
+      case TransactionType.earnedPurchase:
+        writer.writeByte(0);
+      case TransactionType.earnedReferral:
+        writer.writeByte(1);
+      case TransactionType.earnedPromotion:
+        writer.writeByte(2);
+      case TransactionType.earnedBonus:
+        writer.writeByte(3);
+      case TransactionType.redeemedReward:
+        writer.writeByte(4);
+      case TransactionType.redeemedDiscount:
+        writer.writeByte(5);
+      case TransactionType.adjustment:
+        writer.writeByte(6);
+      case TransactionType.expired:
+        writer.writeByte(7);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is TransactionTypeAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class GiftStatusAdapter extends TypeAdapter<GiftStatus> {
+  @override
+  final typeId = 26;
+
+  @override
+  GiftStatus read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return GiftStatus.active;
+      case 1:
+        return GiftStatus.used;
+      case 2:
+        return GiftStatus.expired;
+      case 3:
+        return GiftStatus.reserved;
+      case 4:
+        return GiftStatus.cancelled;
+      default:
+        return GiftStatus.active;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, GiftStatus obj) {
+    switch (obj) {
+      case GiftStatus.active:
+        writer.writeByte(0);
+      case GiftStatus.used:
+        writer.writeByte(1);
+      case GiftStatus.expired:
+        writer.writeByte(2);
+      case GiftStatus.reserved:
+        writer.writeByte(3);
+      case GiftStatus.cancelled:
+        writer.writeByte(4);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is GiftStatusAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class PaymentStatusAdapter extends TypeAdapter<PaymentStatus> {
+  @override
+  final typeId = 27;
+
+  @override
+  PaymentStatus read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return PaymentStatus.pending;
+      case 1:
+        return PaymentStatus.processing;
+      case 2:
+        return PaymentStatus.completed;
+      case 3:
+        return PaymentStatus.failed;
+      case 4:
+        return PaymentStatus.refunded;
+      case 5:
+        return PaymentStatus.cancelled;
+      default:
+        return PaymentStatus.pending;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, PaymentStatus obj) {
+    switch (obj) {
+      case PaymentStatus.pending:
+        writer.writeByte(0);
+      case PaymentStatus.processing:
+        writer.writeByte(1);
+      case PaymentStatus.completed:
+        writer.writeByte(2);
+      case PaymentStatus.failed:
+        writer.writeByte(3);
+      case PaymentStatus.refunded:
+        writer.writeByte(4);
+      case PaymentStatus.cancelled:
+        writer.writeByte(5);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is PaymentStatusAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class NotificationTypeAdapter extends TypeAdapter<NotificationType> {
+  @override
+  final typeId = 28;
+
+  @override
+  NotificationType read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return NotificationType.order;
+      case 1:
+        return NotificationType.promotion;
+      case 2:
+        return NotificationType.system;
+      case 3:
+        return NotificationType.loyalty;
+      case 4:
+        return NotificationType.project;
+      case 5:
+        return NotificationType.payment;
+      case 6:
+        return NotificationType.message;
+      default:
+        return NotificationType.order;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, NotificationType obj) {
+    switch (obj) {
+      case NotificationType.order:
+        writer.writeByte(0);
+      case NotificationType.promotion:
+        writer.writeByte(1);
+      case NotificationType.system:
+        writer.writeByte(2);
+      case NotificationType.loyalty:
+        writer.writeByte(3);
+      case NotificationType.project:
+        writer.writeByte(4);
+      case NotificationType.payment:
+        writer.writeByte(5);
+      case NotificationType.message:
+        writer.writeByte(6);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is NotificationTypeAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}
+
+class PaymentMethodAdapter extends TypeAdapter<PaymentMethod> {
+  @override
+  final typeId = 29;
+
+  @override
+  PaymentMethod read(BinaryReader reader) {
+    switch (reader.readByte()) {
+      case 0:
+        return PaymentMethod.cashOnDelivery;
+      case 1:
+        return PaymentMethod.bankTransfer;
+      case 2:
+        return PaymentMethod.card;
+      case 3:
+        return PaymentMethod.eWallet;
+      case 4:
+        return PaymentMethod.qrCode;
+      case 5:
+        return PaymentMethod.payLater;
+      default:
+        return PaymentMethod.cashOnDelivery;
+    }
+  }
+
+  @override
+  void write(BinaryWriter writer, PaymentMethod obj) {
+    switch (obj) {
+      case PaymentMethod.cashOnDelivery:
+        writer.writeByte(0);
+      case PaymentMethod.bankTransfer:
+        writer.writeByte(1);
+      case PaymentMethod.card:
+        writer.writeByte(2);
+      case PaymentMethod.eWallet:
+        writer.writeByte(3);
+      case PaymentMethod.qrCode:
+        writer.writeByte(4);
+      case PaymentMethod.payLater:
+        writer.writeByte(5);
+    }
+  }
+
+  @override
+  int get hashCode => typeId.hashCode;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is PaymentMethodAdapter &&
+          runtimeType == other.runtimeType &&
+          typeId == other.typeId;
+}