// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'flight_booking_entity.dart';

// **************************************************************************
// BuiltValueGenerator
// **************************************************************************

const FlightBookingEntitySeatTypeEnum _$flightBookingEntitySeatTypeEnum_window =
    const FlightBookingEntitySeatTypeEnum._('window');
const FlightBookingEntitySeatTypeEnum _$flightBookingEntitySeatTypeEnum_middle =
    const FlightBookingEntitySeatTypeEnum._('middle');
const FlightBookingEntitySeatTypeEnum _$flightBookingEntitySeatTypeEnum_aisle =
    const FlightBookingEntitySeatTypeEnum._('aisle');
const FlightBookingEntitySeatTypeEnum
    _$flightBookingEntitySeatTypeEnum_jumpseat =
    const FlightBookingEntitySeatTypeEnum._('jumpseat');
const FlightBookingEntitySeatTypeEnum
    _$flightBookingEntitySeatTypeEnum_captain =
    const FlightBookingEntitySeatTypeEnum._('captain');
const FlightBookingEntitySeatTypeEnum _$flightBookingEntitySeatTypeEnum_pilot =
    const FlightBookingEntitySeatTypeEnum._('pilot');
const FlightBookingEntitySeatTypeEnum
    _$flightBookingEntitySeatTypeEnum_copilot =
    const FlightBookingEntitySeatTypeEnum._('copilot');
const FlightBookingEntitySeatTypeEnum
    _$flightBookingEntitySeatTypeEnum_flightEngineer =
    const FlightBookingEntitySeatTypeEnum._('flightEngineer');
const FlightBookingEntitySeatTypeEnum
    _$flightBookingEntitySeatTypeEnum_flightAttendant =
    const FlightBookingEntitySeatTypeEnum._('flightAttendant');
const FlightBookingEntitySeatTypeEnum
    _$flightBookingEntitySeatTypeEnum_observer =
    const FlightBookingEntitySeatTypeEnum._('observer');
const FlightBookingEntitySeatTypeEnum _$flightBookingEntitySeatTypeEnum_other =
    const FlightBookingEntitySeatTypeEnum._('other');

FlightBookingEntitySeatTypeEnum _$flightBookingEntitySeatTypeEnumValueOf(
    String name) {
  switch (name) {
    case 'window':
      return _$flightBookingEntitySeatTypeEnum_window;
    case 'middle':
      return _$flightBookingEntitySeatTypeEnum_middle;
    case 'aisle':
      return _$flightBookingEntitySeatTypeEnum_aisle;
    case 'jumpseat':
      return _$flightBookingEntitySeatTypeEnum_jumpseat;
    case 'captain':
      return _$flightBookingEntitySeatTypeEnum_captain;
    case 'pilot':
      return _$flightBookingEntitySeatTypeEnum_pilot;
    case 'copilot':
      return _$flightBookingEntitySeatTypeEnum_copilot;
    case 'flightEngineer':
      return _$flightBookingEntitySeatTypeEnum_flightEngineer;
    case 'flightAttendant':
      return _$flightBookingEntitySeatTypeEnum_flightAttendant;
    case 'observer':
      return _$flightBookingEntitySeatTypeEnum_observer;
    case 'other':
      return _$flightBookingEntitySeatTypeEnum_other;
    default:
      throw ArgumentError(name);
  }
}

final BuiltSet<FlightBookingEntitySeatTypeEnum>
    _$flightBookingEntitySeatTypeEnumValues = BuiltSet<
        FlightBookingEntitySeatTypeEnum>(const <FlightBookingEntitySeatTypeEnum>[
  _$flightBookingEntitySeatTypeEnum_window,
  _$flightBookingEntitySeatTypeEnum_middle,
  _$flightBookingEntitySeatTypeEnum_aisle,
  _$flightBookingEntitySeatTypeEnum_jumpseat,
  _$flightBookingEntitySeatTypeEnum_captain,
  _$flightBookingEntitySeatTypeEnum_pilot,
  _$flightBookingEntitySeatTypeEnum_copilot,
  _$flightBookingEntitySeatTypeEnum_flightEngineer,
  _$flightBookingEntitySeatTypeEnum_flightAttendant,
  _$flightBookingEntitySeatTypeEnum_observer,
  _$flightBookingEntitySeatTypeEnum_other,
]);

const FlightBookingEntitySeatingClassEnum
    _$flightBookingEntitySeatingClassEnum_economy =
    const FlightBookingEntitySeatingClassEnum._('economy');
const FlightBookingEntitySeatingClassEnum
    _$flightBookingEntitySeatingClassEnum_premiumEconomy =
    const FlightBookingEntitySeatingClassEnum._('premiumEconomy');
const FlightBookingEntitySeatingClassEnum
    _$flightBookingEntitySeatingClassEnum_business =
    const FlightBookingEntitySeatingClassEnum._('business');
const FlightBookingEntitySeatingClassEnum
    _$flightBookingEntitySeatingClassEnum_first =
    const FlightBookingEntitySeatingClassEnum._('first');
const FlightBookingEntitySeatingClassEnum
    _$flightBookingEntitySeatingClassEnum_private =
    const FlightBookingEntitySeatingClassEnum._('private');
const FlightBookingEntitySeatingClassEnum
    _$flightBookingEntitySeatingClassEnum_other =
    const FlightBookingEntitySeatingClassEnum._('other');

FlightBookingEntitySeatingClassEnum
    _$flightBookingEntitySeatingClassEnumValueOf(String name) {
  switch (name) {
    case 'economy':
      return _$flightBookingEntitySeatingClassEnum_economy;
    case 'premiumEconomy':
      return _$flightBookingEntitySeatingClassEnum_premiumEconomy;
    case 'business':
      return _$flightBookingEntitySeatingClassEnum_business;
    case 'first':
      return _$flightBookingEntitySeatingClassEnum_first;
    case 'private':
      return _$flightBookingEntitySeatingClassEnum_private;
    case 'other':
      return _$flightBookingEntitySeatingClassEnum_other;
    default:
      throw ArgumentError(name);
  }
}

final BuiltSet<FlightBookingEntitySeatingClassEnum>
    _$flightBookingEntitySeatingClassEnumValues = BuiltSet<
        FlightBookingEntitySeatingClassEnum>(const <FlightBookingEntitySeatingClassEnum>[
  _$flightBookingEntitySeatingClassEnum_economy,
  _$flightBookingEntitySeatingClassEnum_premiumEconomy,
  _$flightBookingEntitySeatingClassEnum_business,
  _$flightBookingEntitySeatingClassEnum_first,
  _$flightBookingEntitySeatingClassEnum_private,
  _$flightBookingEntitySeatingClassEnum_other,
]);

const FlightBookingEntityReasonEnum _$flightBookingEntityReasonEnum_personal =
    const FlightBookingEntityReasonEnum._('personal');
const FlightBookingEntityReasonEnum _$flightBookingEntityReasonEnum_business =
    const FlightBookingEntityReasonEnum._('business');
const FlightBookingEntityReasonEnum _$flightBookingEntityReasonEnum_crew =
    const FlightBookingEntityReasonEnum._('crew');
const FlightBookingEntityReasonEnum _$flightBookingEntityReasonEnum_training =
    const FlightBookingEntityReasonEnum._('training');
const FlightBookingEntityReasonEnum
    _$flightBookingEntityReasonEnum_repositioning =
    const FlightBookingEntityReasonEnum._('repositioning');
const FlightBookingEntityReasonEnum _$flightBookingEntityReasonEnum_other =
    const FlightBookingEntityReasonEnum._('other');

FlightBookingEntityReasonEnum _$flightBookingEntityReasonEnumValueOf(
    String name) {
  switch (name) {
    case 'personal':
      return _$flightBookingEntityReasonEnum_personal;
    case 'business':
      return _$flightBookingEntityReasonEnum_business;
    case 'crew':
      return _$flightBookingEntityReasonEnum_crew;
    case 'training':
      return _$flightBookingEntityReasonEnum_training;
    case 'repositioning':
      return _$flightBookingEntityReasonEnum_repositioning;
    case 'other':
      return _$flightBookingEntityReasonEnum_other;
    default:
      throw ArgumentError(name);
  }
}

final BuiltSet<FlightBookingEntityReasonEnum>
    _$flightBookingEntityReasonEnumValues = BuiltSet<
        FlightBookingEntityReasonEnum>(const <FlightBookingEntityReasonEnum>[
  _$flightBookingEntityReasonEnum_personal,
  _$flightBookingEntityReasonEnum_business,
  _$flightBookingEntityReasonEnum_crew,
  _$flightBookingEntityReasonEnum_training,
  _$flightBookingEntityReasonEnum_repositioning,
  _$flightBookingEntityReasonEnum_other,
]);

Serializer<FlightBookingEntitySeatTypeEnum>
    _$flightBookingEntitySeatTypeEnumSerializer =
    _$FlightBookingEntitySeatTypeEnumSerializer();
Serializer<FlightBookingEntitySeatingClassEnum>
    _$flightBookingEntitySeatingClassEnumSerializer =
    _$FlightBookingEntitySeatingClassEnumSerializer();
Serializer<FlightBookingEntityReasonEnum>
    _$flightBookingEntityReasonEnumSerializer =
    _$FlightBookingEntityReasonEnumSerializer();

class _$FlightBookingEntitySeatTypeEnumSerializer
    implements PrimitiveSerializer<FlightBookingEntitySeatTypeEnum> {
  static const Map<String, Object> _toWire = const <String, Object>{
    'window': 'window',
    'middle': 'middle',
    'aisle': 'aisle',
    'jumpseat': 'jumpseat',
    'captain': 'captain',
    'pilot': 'pilot',
    'copilot': 'copilot',
    'flightEngineer': 'flight_engineer',
    'flightAttendant': 'flight_attendant',
    'observer': 'observer',
    'other': 'other',
  };
  static const Map<Object, String> _fromWire = const <Object, String>{
    'window': 'window',
    'middle': 'middle',
    'aisle': 'aisle',
    'jumpseat': 'jumpseat',
    'captain': 'captain',
    'pilot': 'pilot',
    'copilot': 'copilot',
    'flight_engineer': 'flightEngineer',
    'flight_attendant': 'flightAttendant',
    'observer': 'observer',
    'other': 'other',
  };

  @override
  final Iterable<Type> types = const <Type>[FlightBookingEntitySeatTypeEnum];
  @override
  final String wireName = 'FlightBookingEntitySeatTypeEnum';

  @override
  Object serialize(
          Serializers serializers, FlightBookingEntitySeatTypeEnum object,
          {FullType specifiedType = FullType.unspecified}) =>
      _toWire[object.name] ?? object.name;

  @override
  FlightBookingEntitySeatTypeEnum deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      FlightBookingEntitySeatTypeEnum.valueOf(
          _fromWire[serialized] ?? (serialized is String ? serialized : ''));
}

class _$FlightBookingEntitySeatingClassEnumSerializer
    implements PrimitiveSerializer<FlightBookingEntitySeatingClassEnum> {
  static const Map<String, Object> _toWire = const <String, Object>{
    'economy': 'economy',
    'premiumEconomy': 'premium_economy',
    'business': 'business',
    'first': 'first',
    'private': 'private',
    'other': 'other',
  };
  static const Map<Object, String> _fromWire = const <Object, String>{
    'economy': 'economy',
    'premium_economy': 'premiumEconomy',
    'business': 'business',
    'first': 'first',
    'private': 'private',
    'other': 'other',
  };

  @override
  final Iterable<Type> types = const <Type>[
    FlightBookingEntitySeatingClassEnum
  ];
  @override
  final String wireName = 'FlightBookingEntitySeatingClassEnum';

  @override
  Object serialize(
          Serializers serializers, FlightBookingEntitySeatingClassEnum object,
          {FullType specifiedType = FullType.unspecified}) =>
      _toWire[object.name] ?? object.name;

  @override
  FlightBookingEntitySeatingClassEnum deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      FlightBookingEntitySeatingClassEnum.valueOf(
          _fromWire[serialized] ?? (serialized is String ? serialized : ''));
}

class _$FlightBookingEntityReasonEnumSerializer
    implements PrimitiveSerializer<FlightBookingEntityReasonEnum> {
  static const Map<String, Object> _toWire = const <String, Object>{
    'personal': 'personal',
    'business': 'business',
    'crew': 'crew',
    'training': 'training',
    'repositioning': 'repositioning',
    'other': 'other',
  };
  static const Map<Object, String> _fromWire = const <Object, String>{
    'personal': 'personal',
    'business': 'business',
    'crew': 'crew',
    'training': 'training',
    'repositioning': 'repositioning',
    'other': 'other',
  };

  @override
  final Iterable<Type> types = const <Type>[FlightBookingEntityReasonEnum];
  @override
  final String wireName = 'FlightBookingEntityReasonEnum';

  @override
  Object serialize(
          Serializers serializers, FlightBookingEntityReasonEnum object,
          {FullType specifiedType = FullType.unspecified}) =>
      _toWire[object.name] ?? object.name;

  @override
  FlightBookingEntityReasonEnum deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      FlightBookingEntityReasonEnum.valueOf(
          _fromWire[serialized] ?? (serialized is String ? serialized : ''));
}

class _$FlightBookingEntity extends FlightBookingEntity {
  @override
  final String id;
  @override
  final JsonObject? bookingCode;
  @override
  final JsonObject? seatNumber;
  @override
  final FlightBookingEntitySeatTypeEnum? seatType;
  @override
  final FlightBookingEntitySeatingClassEnum? seatingClass;
  @override
  final FlightBookingEntityReasonEnum? reason;
  @override
  final JsonObject? notes;
  @override
  final String flightId;
  @override
  final String userId;
  @override
  final DateTime createdAt;
  @override
  final DateTime updatedAt;

  factory _$FlightBookingEntity(
          [void Function(FlightBookingEntityBuilder)? updates]) =>
      (FlightBookingEntityBuilder()..update(updates))._build();

  _$FlightBookingEntity._(
      {required this.id,
      this.bookingCode,
      this.seatNumber,
      this.seatType,
      this.seatingClass,
      this.reason,
      this.notes,
      required this.flightId,
      required this.userId,
      required this.createdAt,
      required this.updatedAt})
      : super._();
  @override
  FlightBookingEntity rebuild(
          void Function(FlightBookingEntityBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  FlightBookingEntityBuilder toBuilder() =>
      FlightBookingEntityBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is FlightBookingEntity &&
        id == other.id &&
        bookingCode == other.bookingCode &&
        seatNumber == other.seatNumber &&
        seatType == other.seatType &&
        seatingClass == other.seatingClass &&
        reason == other.reason &&
        notes == other.notes &&
        flightId == other.flightId &&
        userId == other.userId &&
        createdAt == other.createdAt &&
        updatedAt == other.updatedAt;
  }

  @override
  int get hashCode {
    var _$hash = 0;
    _$hash = $jc(_$hash, id.hashCode);
    _$hash = $jc(_$hash, bookingCode.hashCode);
    _$hash = $jc(_$hash, seatNumber.hashCode);
    _$hash = $jc(_$hash, seatType.hashCode);
    _$hash = $jc(_$hash, seatingClass.hashCode);
    _$hash = $jc(_$hash, reason.hashCode);
    _$hash = $jc(_$hash, notes.hashCode);
    _$hash = $jc(_$hash, flightId.hashCode);
    _$hash = $jc(_$hash, userId.hashCode);
    _$hash = $jc(_$hash, createdAt.hashCode);
    _$hash = $jc(_$hash, updatedAt.hashCode);
    _$hash = $jf(_$hash);
    return _$hash;
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(r'FlightBookingEntity')
          ..add('id', id)
          ..add('bookingCode', bookingCode)
          ..add('seatNumber', seatNumber)
          ..add('seatType', seatType)
          ..add('seatingClass', seatingClass)
          ..add('reason', reason)
          ..add('notes', notes)
          ..add('flightId', flightId)
          ..add('userId', userId)
          ..add('createdAt', createdAt)
          ..add('updatedAt', updatedAt))
        .toString();
  }
}

class FlightBookingEntityBuilder
    implements Builder<FlightBookingEntity, FlightBookingEntityBuilder> {
  _$FlightBookingEntity? _$v;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  JsonObject? _bookingCode;
  JsonObject? get bookingCode => _$this._bookingCode;
  set bookingCode(JsonObject? bookingCode) => _$this._bookingCode = bookingCode;

  JsonObject? _seatNumber;
  JsonObject? get seatNumber => _$this._seatNumber;
  set seatNumber(JsonObject? seatNumber) => _$this._seatNumber = seatNumber;

  FlightBookingEntitySeatTypeEnum? _seatType;
  FlightBookingEntitySeatTypeEnum? get seatType => _$this._seatType;
  set seatType(FlightBookingEntitySeatTypeEnum? seatType) =>
      _$this._seatType = seatType;

  FlightBookingEntitySeatingClassEnum? _seatingClass;
  FlightBookingEntitySeatingClassEnum? get seatingClass => _$this._seatingClass;
  set seatingClass(FlightBookingEntitySeatingClassEnum? seatingClass) =>
      _$this._seatingClass = seatingClass;

  FlightBookingEntityReasonEnum? _reason;
  FlightBookingEntityReasonEnum? get reason => _$this._reason;
  set reason(FlightBookingEntityReasonEnum? reason) => _$this._reason = reason;

  JsonObject? _notes;
  JsonObject? get notes => _$this._notes;
  set notes(JsonObject? notes) => _$this._notes = notes;

  String? _flightId;
  String? get flightId => _$this._flightId;
  set flightId(String? flightId) => _$this._flightId = flightId;

  String? _userId;
  String? get userId => _$this._userId;
  set userId(String? userId) => _$this._userId = userId;

  DateTime? _createdAt;
  DateTime? get createdAt => _$this._createdAt;
  set createdAt(DateTime? createdAt) => _$this._createdAt = createdAt;

  DateTime? _updatedAt;
  DateTime? get updatedAt => _$this._updatedAt;
  set updatedAt(DateTime? updatedAt) => _$this._updatedAt = updatedAt;

  FlightBookingEntityBuilder() {
    FlightBookingEntity._defaults(this);
  }

  FlightBookingEntityBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _id = $v.id;
      _bookingCode = $v.bookingCode;
      _seatNumber = $v.seatNumber;
      _seatType = $v.seatType;
      _seatingClass = $v.seatingClass;
      _reason = $v.reason;
      _notes = $v.notes;
      _flightId = $v.flightId;
      _userId = $v.userId;
      _createdAt = $v.createdAt;
      _updatedAt = $v.updatedAt;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(FlightBookingEntity other) {
    _$v = other as _$FlightBookingEntity;
  }

  @override
  void update(void Function(FlightBookingEntityBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  FlightBookingEntity build() => _build();

  _$FlightBookingEntity _build() {
    final _$result = _$v ??
        _$FlightBookingEntity._(
          id: BuiltValueNullFieldError.checkNotNull(
              id, r'FlightBookingEntity', 'id'),
          bookingCode: bookingCode,
          seatNumber: seatNumber,
          seatType: seatType,
          seatingClass: seatingClass,
          reason: reason,
          notes: notes,
          flightId: BuiltValueNullFieldError.checkNotNull(
              flightId, r'FlightBookingEntity', 'flightId'),
          userId: BuiltValueNullFieldError.checkNotNull(
              userId, r'FlightBookingEntity', 'userId'),
          createdAt: BuiltValueNullFieldError.checkNotNull(
              createdAt, r'FlightBookingEntity', 'createdAt'),
          updatedAt: BuiltValueNullFieldError.checkNotNull(
              updatedAt, r'FlightBookingEntity', 'updatedAt'),
        );
    replace(_$result);
    return _$result;
  }
}

// ignore_for_file: deprecated_member_use_from_same_package,type=lint