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