// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'imported_loads_model.dart';

// **************************************************************************
// JsonSerializableGenerator
// **************************************************************************

_ImportedLoadsModel _$ImportedLoadsModelFromJson(
  Map<String, dynamic> json,
) => _ImportedLoadsModel(
  id: (json['id'] as num?)?.toInt(),
  product: json['product'] == null
      ? null
      : Product.fromJson(json['product'] as Map<String, dynamic>),
  killHouse: json['kill_house'] == null
      ? null
      : KillHouse.fromJson(json['kill_house'] as Map<String, dynamic>),
  toKillHouse: json['to_kill_house'],
  steward: json['steward'],
  toSteward: json['to_steward'] == null
      ? null
      : ToSteward.fromJson(json['to_steward'] as Map<String, dynamic>),
  guilds: json['guilds'],
  toGuilds: json['to_guilds'],
  toColdHouse: json['to_cold_house'],
  indexWeight: (json['index_weight'] as num?)?.toInt(),
  dateTimestamp: (json['date_timestamp'] as num?)?.toInt(),
  newState: (json['new_state'] as num?)?.toInt(),
  newReceiverState: (json['new_receiver_state'] as num?)?.toInt(),
  newAllocationState: (json['new_allocation_state'] as num?)?.toInt(),
  key: json['key'] as String?,
  createDate: json['create_date'] as String?,
  modifyDate: json['modify_date'] as String?,
  trash: json['trash'] as bool?,
  numberOfCarcasses: (json['number_of_carcasses'] as num?)?.toInt(),
  realNumberOfCarcasses: (json['real_number_of_carcasses'] as num?)?.toInt(),
  receiverRealNumberOfCarcasses:
      (json['receiver_real_number_of_carcasses'] as num?)?.toInt(),
  weightOfCarcasses: (json['weight_of_carcasses'] as num?)?.toDouble(),
  realWeightOfCarcasses: (json['real_weight_of_carcasses'] as num?)?.toDouble(),
  receiverRealWeightOfCarcasses:
      (json['receiver_real_weight_of_carcasses'] as num?)?.toDouble(),
  weightLossOfCarcasses: (json['weight_loss_of_carcasses'] as num?)?.toDouble(),
  finalRegistration: json['final_registration'] as bool?,
  sellType: json['sell_type'] as String?,
  productName: json['product_name'] as String?,
  sellerType: json['seller_type'] as String?,
  type: json['type'] as String?,
  saleType: json['sale_type'] as String?,
  allocationType: json['allocation_type'] as String?,
  systemRegistrationCode: json['system_registration_code'] as bool?,
  registrationCode: (json['registration_code'] as num?)?.toInt(),
  amount: (json['amount'] as num?)?.toInt(),
  totalAmount: (json['total_amount'] as num?)?.toInt(),
  totalAmountPaid: (json['total_amount_paid'] as num?)?.toInt(),
  totalAmountRemain: (json['total_amount_remain'] as num?)?.toInt(),
  loggedRegistrationCode: json['logged_registration_code'],
  state: json['state'] as String?,
  receiverState: json['receiver_state'] as String?,
  allocationState: json['allocation_state'] as String?,
  date: json['date'] as String?,
  role: json['role'],
  stewardTempKey: json['steward_temp_key'],
  approvedPriceStatus: json['approved_price_status'] as bool?,
  calculateStatus: json['calculate_status'] as bool?,
  temporaryTrash: json['temporary_trash'] as bool?,
  temporaryDeleted: json['temporary_deleted'] as bool?,
  createdBy: json['created_by'],
  modifiedBy: json['modified_by'],
  wareHouse: json['ware_house'],
  stewardWareHouse: json['steward_ware_house'],
  car: json['car'],
  dispenser: json['dispenser'],
);

Map<String, dynamic> _$ImportedLoadsModelToJson(
  _ImportedLoadsModel instance,
) => <String, dynamic>{
  'id': instance.id,
  'product': instance.product,
  'kill_house': instance.killHouse,
  'to_kill_house': instance.toKillHouse,
  'steward': instance.steward,
  'to_steward': instance.toSteward,
  'guilds': instance.guilds,
  'to_guilds': instance.toGuilds,
  'to_cold_house': instance.toColdHouse,
  'index_weight': instance.indexWeight,
  'date_timestamp': instance.dateTimestamp,
  'new_state': instance.newState,
  'new_receiver_state': instance.newReceiverState,
  'new_allocation_state': instance.newAllocationState,
  'key': instance.key,
  'create_date': instance.createDate,
  'modify_date': instance.modifyDate,
  'trash': instance.trash,
  'number_of_carcasses': instance.numberOfCarcasses,
  'real_number_of_carcasses': instance.realNumberOfCarcasses,
  'receiver_real_number_of_carcasses': instance.receiverRealNumberOfCarcasses,
  'weight_of_carcasses': instance.weightOfCarcasses,
  'real_weight_of_carcasses': instance.realWeightOfCarcasses,
  'receiver_real_weight_of_carcasses': instance.receiverRealWeightOfCarcasses,
  'weight_loss_of_carcasses': instance.weightLossOfCarcasses,
  'final_registration': instance.finalRegistration,
  'sell_type': instance.sellType,
  'product_name': instance.productName,
  'seller_type': instance.sellerType,
  'type': instance.type,
  'sale_type': instance.saleType,
  'allocation_type': instance.allocationType,
  'system_registration_code': instance.systemRegistrationCode,
  'registration_code': instance.registrationCode,
  'amount': instance.amount,
  'total_amount': instance.totalAmount,
  'total_amount_paid': instance.totalAmountPaid,
  'total_amount_remain': instance.totalAmountRemain,
  'logged_registration_code': instance.loggedRegistrationCode,
  'state': instance.state,
  'receiver_state': instance.receiverState,
  'allocation_state': instance.allocationState,
  'date': instance.date,
  'role': instance.role,
  'steward_temp_key': instance.stewardTempKey,
  'approved_price_status': instance.approvedPriceStatus,
  'calculate_status': instance.calculateStatus,
  'temporary_trash': instance.temporaryTrash,
  'temporary_deleted': instance.temporaryDeleted,
  'created_by': instance.createdBy,
  'modified_by': instance.modifiedBy,
  'ware_house': instance.wareHouse,
  'steward_ware_house': instance.stewardWareHouse,
  'car': instance.car,
  'dispenser': instance.dispenser,
};

_Product _$ProductFromJson(Map<String, dynamic> json) =>
    _Product(weightAverage: (json['weight_average'] as num?)?.toDouble());

Map<String, dynamic> _$ProductToJson(_Product instance) => <String, dynamic>{
  'weight_average': instance.weightAverage,
};

_KillHouse _$KillHouseFromJson(Map<String, dynamic> json) => _KillHouse(
  key: json['key'] as String?,
  killHouseOperator: json['kill_house_operator'] == null
      ? null
      : KillHouseOperator.fromJson(
          json['kill_house_operator'] as Map<String, dynamic>,
        ),
  name: json['name'] as String?,
  killer: json['killer'] as bool?,
);

Map<String, dynamic> _$KillHouseToJson(_KillHouse instance) =>
    <String, dynamic>{
      'key': instance.key,
      'kill_house_operator': instance.killHouseOperator,
      'name': instance.name,
      'killer': instance.killer,
    };

_KillHouseOperator _$KillHouseOperatorFromJson(Map<String, dynamic> json) =>
    _KillHouseOperator(
      user: json['user'] == null
          ? null
          : User.fromJson(json['user'] as Map<String, dynamic>),
    );

Map<String, dynamic> _$KillHouseOperatorToJson(_KillHouseOperator instance) =>
    <String, dynamic>{'user': instance.user};

_User _$UserFromJson(Map<String, dynamic> json) => _User(
  fullname: json['fullname'] as String?,
  firstName: json['first_name'] as String?,
  lastName: json['last_name'] as String?,
  baseOrder: (json['base_order'] as num?)?.toInt(),
  mobile: json['mobile'] as String?,
  nationalId: json['national_id'] as String?,
  nationalCode: json['national_code'] as String?,
  key: json['key'] as String?,
  city: json['city'] == null
      ? null
      : City.fromJson(json['city'] as Map<String, dynamic>),
  unitName: json['unit_name'] as String?,
  unitNationalId: json['unit_national_id'] as String?,
  unitRegistrationNumber: json['unit_registration_number'] as String?,
  unitEconomicalNumber: json['unit_economical_number'] as String?,
  unitProvince: json['unit_province'] as String?,
  unitCity: json['unit_city'] as String?,
  unitPostalCode: json['unit_postal_code'] as String?,
  unitAddress: json['unit_address'] as String?,
);

Map<String, dynamic> _$UserToJson(_User instance) => <String, dynamic>{
  'fullname': instance.fullname,
  'first_name': instance.firstName,
  'last_name': instance.lastName,
  'base_order': instance.baseOrder,
  'mobile': instance.mobile,
  'national_id': instance.nationalId,
  'national_code': instance.nationalCode,
  'key': instance.key,
  'city': instance.city,
  'unit_name': instance.unitName,
  'unit_national_id': instance.unitNationalId,
  'unit_registration_number': instance.unitRegistrationNumber,
  'unit_economical_number': instance.unitEconomicalNumber,
  'unit_province': instance.unitProvince,
  'unit_city': instance.unitCity,
  'unit_postal_code': instance.unitPostalCode,
  'unit_address': instance.unitAddress,
};

_City _$CityFromJson(Map<String, dynamic> json) => _City(
  id: (json['id'] as num?)?.toInt(),
  key: json['key'] as String?,
  createDate: json['create_date'] as String?,
  modifyDate: json['modify_date'] as String?,
  trash: json['trash'] as bool?,
  provinceIdForeignKey: (json['province_id_foreign_key'] as num?)?.toInt(),
  cityIdKey: (json['city_id_key'] as num?)?.toInt(),
  name: json['name'] as String?,
  productPrice: (json['product_price'] as num?)?.toDouble(),
  provinceCenter: json['province_center'] as bool?,
  cityNumber: (json['city_number'] as num?)?.toInt(),
  cityName: json['city_name'] as String?,
  provinceNumber: (json['province_number'] as num?)?.toInt(),
  provinceName: json['province_name'] as String?,
  createdBy: json['created_by'],
  modifiedBy: json['modified_by'],
  province: (json['province'] as num?)?.toInt(),
);

Map<String, dynamic> _$CityToJson(_City instance) => <String, dynamic>{
  'id': instance.id,
  'key': instance.key,
  'create_date': instance.createDate,
  'modify_date': instance.modifyDate,
  'trash': instance.trash,
  'province_id_foreign_key': instance.provinceIdForeignKey,
  'city_id_key': instance.cityIdKey,
  'name': instance.name,
  'product_price': instance.productPrice,
  'province_center': instance.provinceCenter,
  'city_number': instance.cityNumber,
  'city_name': instance.cityName,
  'province_number': instance.provinceNumber,
  'province_name': instance.provinceName,
  'created_by': instance.createdBy,
  'modified_by': instance.modifiedBy,
  'province': instance.province,
};

_ToSteward _$ToStewardFromJson(Map<String, dynamic> json) => _ToSteward(
  id: (json['id'] as num?)?.toInt(),
  user: json['user'] == null
      ? null
      : ToStewardUser.fromJson(json['user'] as Map<String, dynamic>),
  address: json['address'] == null
      ? null
      : Address.fromJson(json['address'] as Map<String, dynamic>),
  guildAreaActivity: json['guild_area_activity'] == null
      ? null
      : Activity.fromJson(json['guild_area_activity'] as Map<String, dynamic>),
  guildTypeActivity: json['guild_type_activity'] == null
      ? null
      : Activity.fromJson(json['guild_type_activity'] as Map<String, dynamic>),
  killHouse: json['kill_house'] as List<dynamic>?,
  stewardKillHouse: json['steward_kill_house'] as List<dynamic>?,
  stewards: json['stewards'] as List<dynamic>?,
  getPosStatus: json['get_pos_status'] == null
      ? null
      : PosStatus.fromJson(json['get_pos_status'] as Map<String, dynamic>),
  key: json['key'] as String?,
  createDate: json['create_date'] as String?,
  modifyDate: json['modify_date'] as String?,
  trash: json['trash'] as bool?,
  userIdForeignKey: json['user_id_foreign_key'],
  addressIdForeignKey: json['address_id_foreign_key'],
  userBankIdForeignKey: json['user_bank_id_foreign_key'],
  walletIdForeignKey: json['wallet_id_foreign_key'],
  provincialGovernmentIdKey: json['provincial_government_id_key'],
  identityDocuments: json['identity_documents'],
  active: json['active'] as bool?,
  cityNumber: (json['city_number'] as num?)?.toInt(),
  cityName: json['city_name'] as String?,
  guildsId: json['guilds_id'] as String?,
  licenseNumber: json['license_number'] as String?,
  guildsName: json['guilds_name'] as String?,
  phone: json['phone'],
  typeActivity: json['type_activity'] as String?,
  areaActivity: json['area_activity'] as String?,
  provinceNumber: (json['province_number'] as num?)?.toInt(),
  provinceName: json['province_name'] as String?,
  steward: json['steward'] as bool?,
  hasPos: json['has_pos'] as bool?,
  centersAllocation: json['centers_allocation'],
  killHouseCentersAllocation: json['kill_house_centers_allocation'],
  allocationLimit: json['allocation_limit'],
  limitationAllocation: json['limitation_allocation'] as bool?,
  registerarRole: json['registerar_role'],
  registerarFullname: json['registerar_fullname'],
  registerarMobile: json['registerar_mobile'],
  killHouseRegister: json['kill_house_register'] as bool?,
  stewardRegister: json['steward_register'] as bool?,
  guildsRoomRegister: json['guilds_room_register'] as bool?,
  posCompanyRegister: json['pos_company_register'] as bool?,
  provinceAcceptState: json['province_accept_state'] as String?,
  provinceMessage: json['province_message'],
  condition: json['condition'],
  descriptionCondition: json['description_condition'],
  stewardActive: json['steward_active'] as bool?,
  stewardAllocationLimit: json['steward_allocation_limit'],
  stewardLimitationAllocation: json['steward_limitation_allocation'] as bool?,
  license: json['license'] as bool?,
  licenseForm: json['license_form'],
  licenseFile: json['license_file'],
  reviewerRole: json['reviewer_role'],
  reviewerFullname: json['reviewer_fullname'],
  reviewerMobile: json['reviewer_mobile'],
  checkerMessage: json['checker_message'],
  finalAccept: json['final_accept'] as bool?,
  temporaryRegistration: json['temporary_registration'] as bool?,
  createdBy: json['created_by'],
  modifiedBy: json['modified_by'],
  userBankInfo: json['user_bank_info'],
  wallet: (json['wallet'] as num?)?.toInt(),
  cars: json['cars'] as List<dynamic>?,
  userLevel: json['user_level'] as List<dynamic>?,
);

Map<String, dynamic> _$ToStewardToJson(_ToSteward instance) =>
    <String, dynamic>{
      'id': instance.id,
      'user': instance.user,
      'address': instance.address,
      'guild_area_activity': instance.guildAreaActivity,
      'guild_type_activity': instance.guildTypeActivity,
      'kill_house': instance.killHouse,
      'steward_kill_house': instance.stewardKillHouse,
      'stewards': instance.stewards,
      'get_pos_status': instance.getPosStatus,
      'key': instance.key,
      'create_date': instance.createDate,
      'modify_date': instance.modifyDate,
      'trash': instance.trash,
      'user_id_foreign_key': instance.userIdForeignKey,
      'address_id_foreign_key': instance.addressIdForeignKey,
      'user_bank_id_foreign_key': instance.userBankIdForeignKey,
      'wallet_id_foreign_key': instance.walletIdForeignKey,
      'provincial_government_id_key': instance.provincialGovernmentIdKey,
      'identity_documents': instance.identityDocuments,
      'active': instance.active,
      'city_number': instance.cityNumber,
      'city_name': instance.cityName,
      'guilds_id': instance.guildsId,
      'license_number': instance.licenseNumber,
      'guilds_name': instance.guildsName,
      'phone': instance.phone,
      'type_activity': instance.typeActivity,
      'area_activity': instance.areaActivity,
      'province_number': instance.provinceNumber,
      'province_name': instance.provinceName,
      'steward': instance.steward,
      'has_pos': instance.hasPos,
      'centers_allocation': instance.centersAllocation,
      'kill_house_centers_allocation': instance.killHouseCentersAllocation,
      'allocation_limit': instance.allocationLimit,
      'limitation_allocation': instance.limitationAllocation,
      'registerar_role': instance.registerarRole,
      'registerar_fullname': instance.registerarFullname,
      'registerar_mobile': instance.registerarMobile,
      'kill_house_register': instance.killHouseRegister,
      'steward_register': instance.stewardRegister,
      'guilds_room_register': instance.guildsRoomRegister,
      'pos_company_register': instance.posCompanyRegister,
      'province_accept_state': instance.provinceAcceptState,
      'province_message': instance.provinceMessage,
      'condition': instance.condition,
      'description_condition': instance.descriptionCondition,
      'steward_active': instance.stewardActive,
      'steward_allocation_limit': instance.stewardAllocationLimit,
      'steward_limitation_allocation': instance.stewardLimitationAllocation,
      'license': instance.license,
      'license_form': instance.licenseForm,
      'license_file': instance.licenseFile,
      'reviewer_role': instance.reviewerRole,
      'reviewer_fullname': instance.reviewerFullname,
      'reviewer_mobile': instance.reviewerMobile,
      'checker_message': instance.checkerMessage,
      'final_accept': instance.finalAccept,
      'temporary_registration': instance.temporaryRegistration,
      'created_by': instance.createdBy,
      'modified_by': instance.modifiedBy,
      'user_bank_info': instance.userBankInfo,
      'wallet': instance.wallet,
      'cars': instance.cars,
      'user_level': instance.userLevel,
    };

_ToStewardUser _$ToStewardUserFromJson(Map<String, dynamic> json) =>
    _ToStewardUser(
      fullname: json['fullname'] as String?,
      firstName: json['first_name'] as String?,
      lastName: json['last_name'] as String?,
      mobile: json['mobile'] as String?,
      nationalId: json['national_id'] as String?,
      city: json['city'] as String?,
    );

Map<String, dynamic> _$ToStewardUserToJson(_ToStewardUser instance) =>
    <String, dynamic>{
      'fullname': instance.fullname,
      'first_name': instance.firstName,
      'last_name': instance.lastName,
      'mobile': instance.mobile,
      'national_id': instance.nationalId,
      'city': instance.city,
    };

_Address _$AddressFromJson(Map<String, dynamic> json) => _Address(
  province: json['province'] == null
      ? null
      : Province.fromJson(json['province'] as Map<String, dynamic>),
  city: json['city'] == null
      ? null
      : CitySimple.fromJson(json['city'] as Map<String, dynamic>),
  address: json['address'] as String?,
  postalCode: json['postal_code'] as String?,
);

Map<String, dynamic> _$AddressToJson(_Address instance) => <String, dynamic>{
  'province': instance.province,
  'city': instance.city,
  'address': instance.address,
  'postal_code': instance.postalCode,
};

_Province _$ProvinceFromJson(Map<String, dynamic> json) =>
    _Province(key: json['key'] as String?, name: json['name'] as String?);

Map<String, dynamic> _$ProvinceToJson(_Province instance) => <String, dynamic>{
  'key': instance.key,
  'name': instance.name,
};

_CitySimple _$CitySimpleFromJson(Map<String, dynamic> json) =>
    _CitySimple(key: json['key'] as String?, name: json['name'] as String?);

Map<String, dynamic> _$CitySimpleToJson(_CitySimple instance) =>
    <String, dynamic>{'key': instance.key, 'name': instance.name};

_Activity _$ActivityFromJson(Map<String, dynamic> json) =>
    _Activity(key: json['key'] as String?, title: json['title'] as String?);

Map<String, dynamic> _$ActivityToJson(_Activity instance) => <String, dynamic>{
  'key': instance.key,
  'title': instance.title,
};

_PosStatus _$PosStatusFromJson(Map<String, dynamic> json) => _PosStatus(
  lenActiveSessions: (json['len_active_sessions'] as num?)?.toInt(),
  hasPons: json['has_pons'] as bool?,
  hasActivePons: json['has_active_pons'] as bool?,
);

Map<String, dynamic> _$PosStatusToJson(_PosStatus instance) =>
    <String, dynamic>{
      'len_active_sessions': instance.lenActiveSessions,
      'has_pons': instance.hasPons,
      'has_active_pons': instance.hasActivePons,
    };
