// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'hard_api_models.dart';

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

OrderEvidenceRequest _$OrderEvidenceRequestFromJson(
        Map<String, dynamic> json) =>
    OrderEvidenceRequest(
      androidOrderCode: json['androidOrderCode'] as String?,
      orderId: json['orderId'] as String?,
      evidenceType: json['evidenceType'] as String,
      evidenceRole: json['evidenceRole'] as String,
      sequenceNo: (json['sequenceNo'] as num).toInt(),
      userId: json['userId'] as String,
      faceSampleId: json['faceSampleId'] as String?,
      referenceImageUrl: json['referenceImageUrl'] as String?,
      referenceImageVersion: json['referenceImageVersion'] == null
          ? null
          : DateTime.parse(json['referenceImageVersion'] as String),
      similarity: (json['similarity'] as num?)?.toDouble(),
      similarityThreshold: (json['similarityThreshold'] as num?)?.toDouble(),
      capturedAt: DateTime.parse(json['capturedAt'] as String),
      imageHash: json['imageHash'] as String?,
      imageSize: (json['imageSize'] as num?)?.toInt(),
      imageWidth: (json['imageWidth'] as num?)?.toInt(),
      imageHeight: (json['imageHeight'] as num?)?.toInt(),
      status: json['status'] as String?,
      failureReason: json['failureReason'] as String?,
      appVersion: json['appVersion'] as String,
    );

Map<String, dynamic> _$OrderEvidenceRequestToJson(
    OrderEvidenceRequest instance) {
  final val = <String, dynamic>{};

  void writeNotNull(String key, dynamic value) {
    if (value != null) {
      val[key] = value;
    }
  }

  writeNotNull('androidOrderCode', instance.androidOrderCode);
  writeNotNull('orderId', instance.orderId);
  val['evidenceType'] = instance.evidenceType;
  val['evidenceRole'] = instance.evidenceRole;
  val['sequenceNo'] = instance.sequenceNo;
  val['userId'] = instance.userId;
  writeNotNull('faceSampleId', instance.faceSampleId);
  writeNotNull('referenceImageUrl', instance.referenceImageUrl);
  writeNotNull('referenceImageVersion',
      instance.referenceImageVersion?.toIso8601String());
  writeNotNull('similarity', instance.similarity);
  writeNotNull('similarityThreshold', instance.similarityThreshold);
  val['capturedAt'] = instance.capturedAt.toIso8601String();
  writeNotNull('imageHash', instance.imageHash);
  writeNotNull('imageSize', instance.imageSize);
  writeNotNull('imageWidth', instance.imageWidth);
  writeNotNull('imageHeight', instance.imageHeight);
  writeNotNull('status', instance.status);
  writeNotNull('failureReason', instance.failureReason);
  val['appVersion'] = instance.appVersion;
  return val;
}

ServiceOrderEvidenceImage _$ServiceOrderEvidenceImageFromJson(
        Map<String, dynamic> json) =>
    ServiceOrderEvidenceImage(
      id: JsonTool.anyToRequiredString(json['id']),
      evidenceType: json['evidenceType'] as String,
      evidenceTypeName: json['evidenceTypeName'] as String?,
      evidenceRole: json['evidenceRole'] as String,
      evidenceRoleName: json['evidenceRoleName'] as String?,
      sequenceNo: (json['sequenceNo'] as num).toInt(),
      status: json['status'] as String,
      statusName: json['statusName'] as String?,
      similarity: JsonTool.anyToNullableDouble(json['similarity']),
      similarityThreshold:
          JsonTool.anyToNullableDouble(json['similarityThreshold']),
      hardId: JsonTool.anyToString(json['hardId']),
      capturedAt: json['capturedAt'] == null
          ? null
          : DateTime.parse(json['capturedAt'] as String),
      imageHash: json['imageHash'] as String?,
      imageUrl: json['imageUrl'] as String?,
      failureReason: json['failureReason'] as String?,
    );

Map<String, dynamic> _$ServiceOrderEvidenceImageToJson(
        ServiceOrderEvidenceImage instance) =>
    <String, dynamic>{
      'id': instance.id,
      'evidenceType': instance.evidenceType,
      'evidenceTypeName': instance.evidenceTypeName,
      'evidenceRole': instance.evidenceRole,
      'evidenceRoleName': instance.evidenceRoleName,
      'sequenceNo': instance.sequenceNo,
      'status': instance.status,
      'statusName': instance.statusName,
      'similarity': instance.similarity,
      'similarityThreshold': instance.similarityThreshold,
      'hardId': instance.hardId,
      'capturedAt': instance.capturedAt?.toIso8601String(),
      'imageHash': instance.imageHash,
      'imageUrl': instance.imageUrl,
      'failureReason': instance.failureReason,
    };

ServicePrintRecord _$ServicePrintRecordFromJson(Map<String, dynamic> json) =>
    ServicePrintRecord(
      id: JsonTool.anyToRequiredString(json['id']),
      orderId: JsonTool.anyToRequiredString(json['orderId']),
      hardId: JsonTool.anyToString(json['hardId']),
      hardName: json['hardName'] as String?,
      printerHardId: JsonTool.anyToString(json['printerHardId']),
      printerHardName: json['printerHardName'] as String?,
      printType: json['printType'] as String? ?? '1',
      printNo: (json['printNo'] as num?)?.toInt() ?? 1,
      retryVersion: (json['retryVersion'] as num?)?.toInt() ?? 0,
      attemptCount: (json['attemptCount'] as num?)?.toInt() ?? 0,
      status: json['status'] as String? ?? '',
      failureStage: json['failureStage'] as String?,
      lastError: json['lastError'] as String?,
      printedAt: json['printedAt'] == null
          ? null
          : DateTime.parse(json['printedAt'] as String),
      reprintReason: json['reprintReason'] as String?,
      pic: json['pic'] as String?,
      createTime: json['createTime'] == null
          ? null
          : DateTime.parse(json['createTime'] as String),
    );

Map<String, dynamic> _$ServicePrintRecordToJson(ServicePrintRecord instance) =>
    <String, dynamic>{
      'id': instance.id,
      'orderId': instance.orderId,
      'hardId': instance.hardId,
      'hardName': instance.hardName,
      'printerHardId': instance.printerHardId,
      'printerHardName': instance.printerHardName,
      'printType': instance.printType,
      'printNo': instance.printNo,
      'retryVersion': instance.retryVersion,
      'attemptCount': instance.attemptCount,
      'status': instance.status,
      'failureStage': instance.failureStage,
      'lastError': instance.lastError,
      'printedAt': instance.printedAt?.toIso8601String(),
      'reprintReason': instance.reprintReason,
      'pic': instance.pic,
      'createTime': instance.createTime?.toIso8601String(),
    };

ServiceOrderEvidenceResolve _$ServiceOrderEvidenceResolveFromJson(
        Map<String, dynamic> json) =>
    ServiceOrderEvidenceResolve(
      orderId: JsonTool.anyToRequiredString(json['orderId']),
      orderStatus: json['orderStatus'] as String,
      evidenceImages: (json['evidenceImages'] as List<dynamic>?)
              ?.map((e) =>
                  ServiceOrderEvidenceImage.fromJson(e as Map<String, dynamic>))
              .toList() ??
          const [],
    );

Map<String, dynamic> _$ServiceOrderEvidenceResolveToJson(
        ServiceOrderEvidenceResolve instance) =>
    <String, dynamic>{
      'orderId': instance.orderId,
      'orderStatus': instance.orderStatus,
      'evidenceImages': instance.evidenceImages,
    };

ServiceOrderEvidenceUploadResult _$ServiceOrderEvidenceUploadResultFromJson(
        Map<String, dynamic> json) =>
    ServiceOrderEvidenceUploadResult(
      evidenceId: JsonTool.anyToRequiredString(json['evidenceId']),
      orderId: JsonTool.anyToRequiredString(json['orderId']),
      status: json['status'] as String,
      uploaded: json['uploaded'] as bool,
      message: json['message'] as String,
      imageUrl: json['imageUrl'] as String?,
    );

Map<String, dynamic> _$ServiceOrderEvidenceUploadResultToJson(
        ServiceOrderEvidenceUploadResult instance) =>
    <String, dynamic>{
      'evidenceId': instance.evidenceId,
      'orderId': instance.orderId,
      'status': instance.status,
      'uploaded': instance.uploaded,
      'message': instance.message,
      'imageUrl': instance.imageUrl,
    };

ServiceHardware _$ServiceHardwareFromJson(Map<String, dynamic> json) =>
    ServiceHardware(
      id: json['id'] as String?,
      name: json['name'] as String?,
      type: json['type'] as String?,
      typeEnum: json['typeEnum'] as String?,
      merchantId: json['merchantId'] as String?,
      merchantDeptId: json['merchantDeptId'] as String?,
      hardGroupId: json['hardGroupId'] as String?,
      merchantStr: json['merchantStr'] as String?,
      mqClientId: json['mqClientId'] as String?,
      uniqueCode: json['uniqueCode'] as String?,
      mainTopic: json['mainTopic'] as String?,
      mqSocketAddress: json['mqSocketAddress'] as String?,
      mqSocketPort: json['mqSocketPort'] as String?,
      mqUsername: json['mqUsername'] as String?,
      mqPassword: json['mqPassword'] as String?,
      mqSyncCount: (json['mqSyncCount'] as num?)?.toInt(),
      faceAppId: json['faceAppId'] as String?,
      faceSdkKey: json['faceSdkKey'] as String?,
      faceActiveKey: json['faceActiveKey'] as String?,
    )
      ..msg = json['msg'] as String?
      ..code = (json['code'] as num?)?.toInt()
      ..data = json['data'];

Map<String, dynamic> _$ServiceHardwareToJson(ServiceHardware instance) =>
    <String, dynamic>{
      'msg': instance.msg,
      'code': instance.code,
      'data': instance.data,
      'id': instance.id,
      'name': instance.name,
      'type': instance.type,
      'typeEnum': instance.typeEnum,
      'merchantId': instance.merchantId,
      'merchantDeptId': instance.merchantDeptId,
      'hardGroupId': instance.hardGroupId,
      'merchantStr': instance.merchantStr,
      'mqClientId': instance.mqClientId,
      'uniqueCode': instance.uniqueCode,
      'mainTopic': instance.mainTopic,
      'mqSocketAddress': instance.mqSocketAddress,
      'mqSocketPort': instance.mqSocketPort,
      'mqUsername': instance.mqUsername,
      'mqPassword': instance.mqPassword,
      'mqSyncCount': instance.mqSyncCount,
      'faceAppId': instance.faceAppId,
      'faceSdkKey': instance.faceSdkKey,
      'faceActiveKey': instance.faceActiveKey,
    };

ServiceCar _$ServiceCarFromJson(Map<String, dynamic> json) => ServiceCar(
      id: JsonTool.anyToString(json['id']),
      parentCarId: JsonTool.anyToString(json['parentCarId']),
      productName: json['productName'] as String?,
      productPrice: (json['productPrice'] as num?)?.toInt(),
      productId: JsonTool.anyToString(json['productId']),
      productCount: (json['productCount'] as num?)?.toInt(),
      productNature: json['productNature'] as String?,
      productWeight: JsonTool.anyToNullableDouble(json['productWeight']),
      totalPrice: JsonTool.anyToNullableInt(json['totalPrice']),
      productPic: json['productPic'] as String?,
    );

Map<String, dynamic> _$ServiceCarToJson(ServiceCar instance) =>
    <String, dynamic>{
      'id': instance.id,
      'parentCarId': instance.parentCarId,
      'productName': instance.productName,
      'productPrice': instance.productPrice,
      'productId': instance.productId,
      'productCount': instance.productCount,
      'productNature': instance.productNature,
      'productWeight': instance.productWeight,
      'totalPrice': JsonTool.intToString(instance.totalPrice),
      'productPic': instance.productPic,
    };

ServiceGenerateInvoice _$ServiceGenerateInvoiceFromJson(
        Map<String, dynamic> json) =>
    ServiceGenerateInvoice(
      pic: json['pic'] as String?,
      historyId: json['historyId'] as String?,
    );

Map<String, dynamic> _$ServiceGenerateInvoiceToJson(
        ServiceGenerateInvoice instance) =>
    <String, dynamic>{
      'pic': instance.pic,
      'historyId': instance.historyId,
    };

ServiceQRCode _$ServiceQRCodeFromJson(Map<String, dynamic> json) =>
    ServiceQRCode(
      id: JsonTool.intToString((json['id'] as num?)?.toInt()),
      itemId: JsonTool.intToString((json['itemId'] as num?)?.toInt()),
      typeId: JsonTool.intToString((json['typeId'] as num?)?.toInt()),
      userId: JsonTool.intToString((json['userId'] as num?)?.toInt()),
      orderType: JsonTool.stringToOrderType(json['orderType'] as String?),
      payType: JsonTool.stringToOrderPayType(json['payType'] as String?),
      exceedTime: (json['exceedTime'] as num?)?.toInt(),
      extra: json['extra'] as String?,
    );

Map<String, dynamic> _$ServiceQRCodeToJson(ServiceQRCode instance) =>
    <String, dynamic>{
      'id': JsonTool.stringToInt(instance.id),
      'itemId': JsonTool.stringToInt(instance.itemId),
      'typeId': JsonTool.stringToInt(instance.typeId),
      'userId': JsonTool.stringToInt(instance.userId),
      'orderType': JsonTool.orderTypeToString(instance.orderType),
      'payType': JsonTool.orderPayTypeToString(instance.payType),
      'exceedTime': instance.exceedTime,
      'extra': instance.extra,
    };

ServiceHardOrder _$ServiceHardOrderFromJson(Map<String, dynamic> json) =>
    ServiceHardOrder(
      id: JsonTool.anyToString(json['id']),
      orderNo: json['orderNo'] as String?,
      userId: JsonTool.anyToString(json['userId']),
      username: json['username'] as String?,
      userMobile: json['userMobile'] as String?,
      userAvatar: json['userAvatar'] as String?,
      orderType: json['orderType'] as String?,
      orderStatus: json['orderStatus'] as String?,
      payType: json['payType'] as String?,
      walletId: JsonTool.anyToString(json['walletId']),
      hourType: json['hourType'] as String?,
      apptHourType: json['apptHourType'] as String?,
      productDesc: json['productDesc'] as String?,
      userDeptName: json['userDeptName'] as String?,
      totalPrice: JsonTool.anyToNullableInt(json['totalPrice']),
      extraPrice: JsonTool.anyToNullableInt(json['extraPrice']),
      payPrice: JsonTool.anyToNullableInt(json['payPrice']),
      androidOrderCode: json['androidOrderCode'] as String?,
      createTime: json['createTime'] == null
          ? null
          : DateTime.parse(json['createTime'] as String),
    );

Map<String, dynamic> _$ServiceHardOrderToJson(ServiceHardOrder instance) =>
    <String, dynamic>{
      'id': instance.id,
      'orderNo': instance.orderNo,
      'userId': instance.userId,
      'username': instance.username,
      'userMobile': instance.userMobile,
      'userAvatar': instance.userAvatar,
      'orderType': instance.orderType,
      'orderStatus': instance.orderStatus,
      'payType': instance.payType,
      'walletId': instance.walletId,
      'hourType': instance.hourType,
      'apptHourType': instance.apptHourType,
      'productDesc': instance.productDesc,
      'userDeptName': instance.userDeptName,
      'totalPrice': instance.totalPrice,
      'extraPrice': instance.extraPrice,
      'payPrice': instance.payPrice,
      'androidOrderCode': instance.androidOrderCode,
      'createTime': instance.createTime?.toIso8601String(),
    };

VerificationRecordQueryRequest _$VerificationRecordQueryRequestFromJson(
        Map<String, dynamic> json) =>
    VerificationRecordQueryRequest(
      hardId: (json['hardId'] as num).toInt(),
      startDate: json['startDate'] as String,
      endDate: json['endDate'] as String,
      verificationType: json['verificationType'] as String?,
      scope: json['scope'] as String?,
    );

Map<String, dynamic> _$VerificationRecordQueryRequestToJson(
    VerificationRecordQueryRequest instance) {
  final val = <String, dynamic>{
    'hardId': instance.hardId,
    'startDate': instance.startDate,
    'endDate': instance.endDate,
  };

  void writeNotNull(String key, dynamic value) {
    if (value != null) {
      val[key] = value;
    }
  }

  writeNotNull('verificationType', instance.verificationType);
  writeNotNull('scope', instance.scope);
  return val;
}

TerminalOrderRecordQueryRequest _$TerminalOrderRecordQueryRequestFromJson(
        Map<String, dynamic> json) =>
    TerminalOrderRecordQueryRequest(
      hardId: (json['hardId'] as num).toInt(),
      startDate: json['startDate'] as String,
      endDate: json['endDate'] as String,
      scope: json['scope'] as String?,
      orderStatusCodes: (json['orderStatusCodes'] as List<dynamic>?)
          ?.map((e) => e as String)
          .toList(),
      hourType: json['hourType'] as String?,
    );

Map<String, dynamic> _$TerminalOrderRecordQueryRequestToJson(
    TerminalOrderRecordQueryRequest instance) {
  final val = <String, dynamic>{
    'hardId': instance.hardId,
    'startDate': instance.startDate,
    'endDate': instance.endDate,
  };

  void writeNotNull(String key, dynamic value) {
    if (value != null) {
      val[key] = value;
    }
  }

  writeNotNull('scope', instance.scope);
  writeNotNull('orderStatusCodes', instance.orderStatusCodes);
  writeNotNull('hourType', instance.hourType);
  return val;
}

ServiceTerminalOrderRecord _$ServiceTerminalOrderRecordFromJson(
        Map<String, dynamic> json) =>
    ServiceTerminalOrderRecord(
      orderId: JsonTool.anyToInt(json['orderId']),
      orderNo: json['orderNo'] as String,
      orderType: json['orderType'] as String,
      orderTypeName: json['orderTypeName'] as String,
      orderStatus: json['orderStatus'] as String,
      orderStatusName: json['orderStatusName'] as String,
      payType: json['payType'] as String,
      payTypeName: json['payTypeName'] as String,
      username: json['username'] as String,
      productDesc: json['productDesc'] as String,
      totalPrice: JsonTool.anyToInt(json['totalPrice']),
      extraPrice: JsonTool.anyToInt(json['extraPrice']),
      payPrice: JsonTool.anyToInt(json['payPrice']),
      userDeptName: json['userDeptName'] as String?,
      hourType: json['hourType'] as String?,
      hardName: json['hardName'] as String?,
      createTime: json['createTime'] == null
          ? null
          : DateTime.parse(json['createTime'] as String),
    );

Map<String, dynamic> _$ServiceTerminalOrderRecordToJson(
        ServiceTerminalOrderRecord instance) =>
    <String, dynamic>{
      'orderId': instance.orderId,
      'orderNo': instance.orderNo,
      'orderType': instance.orderType,
      'orderTypeName': instance.orderTypeName,
      'orderStatus': instance.orderStatus,
      'orderStatusName': instance.orderStatusName,
      'payType': instance.payType,
      'payTypeName': instance.payTypeName,
      'username': instance.username,
      'userDeptName': instance.userDeptName,
      'productDesc': instance.productDesc,
      'hourType': instance.hourType,
      'hardName': instance.hardName,
      'totalPrice': instance.totalPrice,
      'extraPrice': instance.extraPrice,
      'payPrice': instance.payPrice,
      'createTime': instance.createTime?.toIso8601String(),
    };

ServiceTerminalOrderRecordPage _$ServiceTerminalOrderRecordPageFromJson(
        Map<String, dynamic> json) =>
    ServiceTerminalOrderRecordPage(
      records: (json['records'] as List<dynamic>?)
          ?.map((e) =>
              ServiceTerminalOrderRecord.fromJson(e as Map<String, dynamic>))
          .toList(),
    )
      ..current = (json['current'] as num).toInt()
      ..pages = (json['pages'] as num).toInt()
      ..size = (json['size'] as num).toInt()
      ..total = (json['total'] as num).toInt();

Map<String, dynamic> _$ServiceTerminalOrderRecordPageToJson(
        ServiceTerminalOrderRecordPage instance) =>
    <String, dynamic>{
      'current': instance.current,
      'pages': instance.pages,
      'size': instance.size,
      'total': instance.total,
      'records': instance.records,
    };

ServiceVerificationRecord _$ServiceVerificationRecordFromJson(
        Map<String, dynamic> json) =>
    ServiceVerificationRecord(
      orderId: JsonTool.anyToInt(json['orderId']),
      orderNo: json['orderNo'] as String,
      verificationType: json['verificationType'] as String,
      verificationTypeName: json['verificationTypeName'] as String,
      username: json['username'] as String,
      productDesc: json['productDesc'] as String,
      payTypeName: json['payTypeName'] as String,
      totalPrice: JsonTool.anyToInt(json['totalPrice']),
      verificationTime: DateTime.parse(json['verificationTime'] as String),
      userDeptName: json['userDeptName'] as String?,
    );

Map<String, dynamic> _$ServiceVerificationRecordToJson(
        ServiceVerificationRecord instance) =>
    <String, dynamic>{
      'orderId': instance.orderId,
      'orderNo': instance.orderNo,
      'verificationType': instance.verificationType,
      'verificationTypeName': instance.verificationTypeName,
      'username': instance.username,
      'userDeptName': instance.userDeptName,
      'productDesc': instance.productDesc,
      'payTypeName': instance.payTypeName,
      'totalPrice': instance.totalPrice,
      'verificationTime': instance.verificationTime.toIso8601String(),
    };

ServiceVerificationRecordPage _$ServiceVerificationRecordPageFromJson(
        Map<String, dynamic> json) =>
    ServiceVerificationRecordPage(
      records: (json['records'] as List<dynamic>?)
          ?.map((e) =>
              ServiceVerificationRecord.fromJson(e as Map<String, dynamic>))
          .toList(),
    )
      ..current = (json['current'] as num).toInt()
      ..pages = (json['pages'] as num).toInt()
      ..size = (json['size'] as num).toInt()
      ..total = (json['total'] as num).toInt();

Map<String, dynamic> _$ServiceVerificationRecordPageToJson(
        ServiceVerificationRecordPage instance) =>
    <String, dynamic>{
      'current': instance.current,
      'pages': instance.pages,
      'size': instance.size,
      'total': instance.total,
      'records': instance.records,
    };

ServiceOpenCard _$ServiceOpenCardFromJson(Map<String, dynamic> json) =>
    ServiceOpenCard(
      username: json['username'] as String?,
      mobile: json['mobile'] as String?,
      avatar: json['avatar'] as String?,
      cardStatus: json['cardStatus'] as String?,
      id: json['id'] as String?,
      deptId: json['deptId'] as String?,
      deptName: json['deptName'] as String?,
      userId: json['userId'] as String?,
      walletTypeId: json['walletTypeId'] as String?,
      walletTypeUniqueCode: json['walletTypeUniqueCode'] as String?,
      walletTypeIcon: json['walletTypeIcon'] as String?,
      cardNumber: json['cardNumber'] as String?,
      walletId: json['walletId'] as String?,
      isActiveHardware:
          JsonTool.stringToBoolean(json['isActiveHardware'] as String?),
    );

Map<String, dynamic> _$ServiceOpenCardToJson(ServiceOpenCard instance) =>
    <String, dynamic>{
      'username': instance.username,
      'mobile': instance.mobile,
      'avatar': instance.avatar,
      'cardStatus': instance.cardStatus,
      'id': instance.id,
      'deptId': instance.deptId,
      'deptName': instance.deptName,
      'userId': instance.userId,
      'walletTypeId': instance.walletTypeId,
      'walletTypeUniqueCode': instance.walletTypeUniqueCode,
      'walletTypeIcon': instance.walletTypeIcon,
      'cardNumber': instance.cardNumber,
      'walletId': instance.walletId,
      'isActiveHardware': JsonTool.booleanToString(instance.isActiveHardware),
    };

ServiceOpenCardPage _$ServiceOpenCardPageFromJson(Map<String, dynamic> json) =>
    ServiceOpenCardPage(
      records: (json['records'] as List<dynamic>?)
          ?.map((e) => ServiceOpenCard.fromJson(e as Map<String, dynamic>))
          .toList(),
    )
      ..current = (json['current'] as num).toInt()
      ..pages = (json['pages'] as num).toInt()
      ..size = (json['size'] as num).toInt()
      ..total = (json['total'] as num).toInt();

Map<String, dynamic> _$ServiceOpenCardPageToJson(
        ServiceOpenCardPage instance) =>
    <String, dynamic>{
      'current': instance.current,
      'pages': instance.pages,
      'size': instance.size,
      'total': instance.total,
      'records': instance.records,
    };

ServiceChartLatitude _$ServiceChartLatitudeFromJson(
        Map<String, dynamic> json) =>
    ServiceChartLatitude(
      dayTotal: (json['dayTotal'] as List<dynamic>)
          .map((e) =>
              ServiceChartLatitudeItem.fromJson(e as Map<String, dynamic>))
          .toList(),
      weekTotal: (json['weekTotal'] as List<dynamic>)
          .map((e) =>
              ServiceChartLatitudeItem.fromJson(e as Map<String, dynamic>))
          .toList(),
      monthTotal: (json['monthTotal'] as List<dynamic>)
          .map((e) =>
              ServiceChartLatitudeItem.fromJson(e as Map<String, dynamic>))
          .toList(),
      yearTotal: (json['yearTotal'] as List<dynamic>)
          .map((e) =>
              ServiceChartLatitudeItem.fromJson(e as Map<String, dynamic>))
          .toList(),
      allTotal: (json['allTotal'] as List<dynamic>)
          .map((e) =>
              ServiceChartLatitudeItem.fromJson(e as Map<String, dynamic>))
          .toList(),
    );

Map<String, dynamic> _$ServiceChartLatitudeToJson(
        ServiceChartLatitude instance) =>
    <String, dynamic>{
      'dayTotal': instance.dayTotal,
      'weekTotal': instance.weekTotal,
      'monthTotal': instance.monthTotal,
      'yearTotal': instance.yearTotal,
      'allTotal': instance.allTotal,
    };

ServiceChartLatitudeItem _$ServiceChartLatitudeItemFromJson(
        Map<String, dynamic> json) =>
    ServiceChartLatitudeItem(
      hourType: json['hourType'] as String?,
      deptId: json['deptId'] as String?,
      sum: json['sum'] as String?,
      count: json['count'] as String?,
    );

Map<String, dynamic> _$ServiceChartLatitudeItemToJson(
        ServiceChartLatitudeItem instance) =>
    <String, dynamic>{
      'hourType': instance.hourType,
      'deptId': instance.deptId,
      'sum': instance.sum,
      'count': instance.count,
    };

ServiceBroadcastToday _$ServiceBroadcastTodayFromJson(
        Map<String, dynamic> json) =>
    ServiceBroadcastToday(
      id: json['id'] as String,
      userId: json['userId'] as String,
      username: json['username'] as String,
      userMobile: json['userMobile'] as String,
      hardId: json['hardId'] as String,
      topic: json['topic'] as String,
      bizType: json['bizType'] as String?,
      bizId: json['bizId'] as String?,
      title: json['title'] as String,
      content: json['content'] as String,
      broadcastCount: (json['broadcastCount'] as num?)?.toInt(),
      broadcastMaxCount: (json['broadcastMaxCount'] as num?)?.toInt(),
      isBroadcast: JsonTool.stringToBoolean(json['isBroadcast'] as String?),
      hourType: json['hourType'] as String?,
      productDesc: json['productDesc'] as String,
      payPrice: (json['payPrice'] as num).toInt(),
      createTime: json['createTime'] as String,
    );

Map<String, dynamic> _$ServiceBroadcastTodayToJson(
        ServiceBroadcastToday instance) =>
    <String, dynamic>{
      'id': instance.id,
      'userId': instance.userId,
      'username': instance.username,
      'userMobile': instance.userMobile,
      'hardId': instance.hardId,
      'topic': instance.topic,
      'bizType': instance.bizType,
      'bizId': instance.bizId,
      'title': instance.title,
      'content': instance.content,
      'broadcastCount': instance.broadcastCount,
      'broadcastMaxCount': instance.broadcastMaxCount,
      'isBroadcast': JsonTool.booleanToString(instance.isBroadcast),
      'hourType': instance.hourType,
      'productDesc': instance.productDesc,
      'payPrice': instance.payPrice,
      'createTime': instance.createTime,
    };

ServiceBroadcastTodayPage _$ServiceBroadcastTodayPageFromJson(
        Map<String, dynamic> json) =>
    ServiceBroadcastTodayPage(
      records: (json['records'] as List<dynamic>?)
          ?.map(
              (e) => ServiceBroadcastToday.fromJson(e as Map<String, dynamic>))
          .toList(),
    )
      ..current = (json['current'] as num).toInt()
      ..pages = (json['pages'] as num).toInt()
      ..size = (json['size'] as num).toInt()
      ..total = (json['total'] as num).toInt();

Map<String, dynamic> _$ServiceBroadcastTodayPageToJson(
        ServiceBroadcastTodayPage instance) =>
    <String, dynamic>{
      'current': instance.current,
      'pages': instance.pages,
      'size': instance.size,
      'total': instance.total,
      'records': instance.records,
    };

ServiceHardCreateHardQrCodeScanOrder
    _$ServiceHardCreateHardQrCodeScanOrderFromJson(Map<String, dynamic> json) =>
        ServiceHardCreateHardQrCodeScanOrder(
          orderId: json['orderId'] as String,
          mchId: json['mchId'] as String,
          qrCodeData: json['qrCodeData'] as String,
        );

Map<String, dynamic> _$ServiceHardCreateHardQrCodeScanOrderToJson(
        ServiceHardCreateHardQrCodeScanOrder instance) =>
    <String, dynamic>{
      'orderId': instance.orderId,
      'mchId': instance.mchId,
      'qrCodeData': instance.qrCodeData,
    };

ServiceHardAggregateOrderCodePay _$ServiceHardAggregateOrderCodePayFromJson(
        Map<String, dynamic> json) =>
    ServiceHardAggregateOrderCodePay(
      orderId: json['orderId'] as String,
      mchId: json['mchId'] as String,
      aggregateNo: json['aggregateNo'] as String,
      qrCode: json['qrCode'] as String,
      qrCodeType: json['qrCodeType'] as String,
      expireTime: DateTime.parse(json['expireTime'] as String),
    );

Map<String, dynamic> _$ServiceHardAggregateOrderCodePayToJson(
        ServiceHardAggregateOrderCodePay instance) =>
    <String, dynamic>{
      'orderId': instance.orderId,
      'mchId': instance.mchId,
      'aggregateNo': instance.aggregateNo,
      'qrCode': instance.qrCode,
      'qrCodeType': instance.qrCodeType,
      'expireTime': instance.expireTime.toIso8601String(),
    };

ServiceHardAggregateOrderCodePayStatus
    _$ServiceHardAggregateOrderCodePayStatusFromJson(
            Map<String, dynamic> json) =>
        ServiceHardAggregateOrderCodePayStatus(
          orderId: json['orderId'] as String,
          aggregateNo: json['aggregateNo'] as String,
          status: json['status'] as String,
          selectedPlatform: json['selectedPlatform'] as String?,
          payNo: json['payNo'] as String?,
          paySuccess: json['paySuccess'] as bool,
          expireTime: json['expireTime'] == null
              ? null
              : DateTime.parse(json['expireTime'] as String),
          orderStatus: json['orderStatus'] as String,
        );

Map<String, dynamic> _$ServiceHardAggregateOrderCodePayStatusToJson(
        ServiceHardAggregateOrderCodePayStatus instance) =>
    <String, dynamic>{
      'orderId': instance.orderId,
      'aggregateNo': instance.aggregateNo,
      'status': instance.status,
      'selectedPlatform': instance.selectedPlatform,
      'payNo': instance.payNo,
      'paySuccess': instance.paySuccess,
      'expireTime': instance.expireTime?.toIso8601String(),
      'orderStatus': instance.orderStatus,
    };

ReservationMenuQueryRequest _$ReservationMenuQueryRequestFromJson(
        Map<String, dynamic> json) =>
    ReservationMenuQueryRequest(
      hardId: (json['hardId'] as num).toInt(),
      recognitionType: json['recognitionType'] as String,
      maskName: json['maskName'] as bool,
      cardNumber: json['cardNumber'] as String?,
      faceUserId: (json['faceUserId'] as num?)?.toInt(),
    );

Map<String, dynamic> _$ReservationMenuQueryRequestToJson(
    ReservationMenuQueryRequest instance) {
  final val = <String, dynamic>{
    'hardId': instance.hardId,
    'recognitionType': instance.recognitionType,
    'maskName': instance.maskName,
  };

  void writeNotNull(String key, dynamic value) {
    if (value != null) {
      val[key] = value;
    }
  }

  writeNotNull('cardNumber', instance.cardNumber);
  writeNotNull('faceUserId', instance.faceUserId);
  return val;
}

ServiceReservationMenuQuery _$ServiceReservationMenuQueryFromJson(
        Map<String, dynamic> json) =>
    ServiceReservationMenuQuery(
      maskedName: json['maskedName'] as String,
      deptName: json['deptName'] as String?,
      merchantName: json['merchantName'] as String,
      totalDayCount: (json['totalDayCount'] as num).toInt(),
      totalMealCount: (json['totalMealCount'] as num).toInt(),
      days: (json['days'] as List<dynamic>)
          .map((e) => ServiceReservationDay.fromJson(e as Map<String, dynamic>))
          .toList(),
    );

Map<String, dynamic> _$ServiceReservationMenuQueryToJson(
        ServiceReservationMenuQuery instance) =>
    <String, dynamic>{
      'maskedName': instance.maskedName,
      'deptName': instance.deptName,
      'merchantName': instance.merchantName,
      'totalDayCount': instance.totalDayCount,
      'totalMealCount': instance.totalMealCount,
      'days': instance.days.map((e) => e.toJson()).toList(),
    };

ServiceReservationDay _$ServiceReservationDayFromJson(
        Map<String, dynamic> json) =>
    ServiceReservationDay(
      date: json['date'] as String,
      meals: (json['meals'] as List<dynamic>)
          .map(
              (e) => ServiceReservationMeal.fromJson(e as Map<String, dynamic>))
          .toList(),
    );

Map<String, dynamic> _$ServiceReservationDayToJson(
        ServiceReservationDay instance) =>
    <String, dynamic>{
      'date': instance.date,
      'meals': instance.meals.map((e) => e.toJson()).toList(),
    };

ServiceReservationMeal _$ServiceReservationMealFromJson(
        Map<String, dynamic> json) =>
    ServiceReservationMeal(
      hourType: json['hourType'] as String,
      mealTitle: json['mealTitle'] as String,
      items: (json['items'] as List<dynamic>).map((e) => e as String).toList(),
      orderIds: json['orderIds'] == null
          ? const []
          : JsonTool.anyListToIntList(json['orderIds']),
      orders: (json['orders'] as List<dynamic>?)
              ?.map((e) =>
                  ServiceReservationOrder.fromJson(e as Map<String, dynamic>))
              .toList() ??
          const [],
    );

Map<String, dynamic> _$ServiceReservationMealToJson(
        ServiceReservationMeal instance) =>
    <String, dynamic>{
      'hourType': instance.hourType,
      'mealTitle': instance.mealTitle,
      'items': instance.items,
      'orderIds': instance.orderIds,
      'orders': instance.orders.map((e) => e.toJson()).toList(),
    };

ServiceReservationOrder _$ServiceReservationOrderFromJson(
        Map<String, dynamic> json) =>
    ServiceReservationOrder(
      orderId: JsonTool.anyToInt(json['orderId']),
      items: (json['items'] as List<dynamic>)
          .map((e) =>
              ServiceReservationOrderItem.fromJson(e as Map<String, dynamic>))
          .toList(),
    );

Map<String, dynamic> _$ServiceReservationOrderToJson(
        ServiceReservationOrder instance) =>
    <String, dynamic>{
      'orderId': instance.orderId,
      'items': instance.items.map((e) => e.toJson()).toList(),
    };

ServiceReservationOrderItem _$ServiceReservationOrderItemFromJson(
        Map<String, dynamic> json) =>
    ServiceReservationOrderItem(
      productId: JsonTool.anyToNullableInt(json['productId']),
      productName: json['productName'] as String,
      productPic: json['productPic'] as String?,
      productCount: (json['productCount'] as num?)?.toInt(),
      spuType: (json['spuType'] as num?)?.toInt() ?? 1,
      comboItems: (json['comboItems'] as List<dynamic>?)
              ?.map((e) => ServiceReservationComboItem.fromJson(
                  e as Map<String, dynamic>))
              .toList() ??
          const [],
    );

Map<String, dynamic> _$ServiceReservationOrderItemToJson(
        ServiceReservationOrderItem instance) =>
    <String, dynamic>{
      'productId': instance.productId,
      'productName': instance.productName,
      'productPic': instance.productPic,
      'productCount': instance.productCount,
      'spuType': instance.spuType,
      'comboItems': instance.comboItems.map((e) => e.toJson()).toList(),
    };

ServiceReservationComboItem _$ServiceReservationComboItemFromJson(
        Map<String, dynamic> json) =>
    ServiceReservationComboItem(
      childSpuId: JsonTool.anyToNullableInt(json['childSpuId']),
      name: json['name'] as String?,
      picUrl: json['picUrl'] as String?,
      quantity: (json['quantity'] as num?)?.toInt(),
      sortOrder: (json['sortOrder'] as num?)?.toInt(),
      price: (json['price'] as num?)?.toInt(),
    );

Map<String, dynamic> _$ServiceReservationComboItemToJson(
        ServiceReservationComboItem instance) =>
    <String, dynamic>{
      'childSpuId': instance.childSpuId,
      'name': instance.name,
      'picUrl': instance.picUrl,
      'quantity': instance.quantity,
      'sortOrder': instance.sortOrder,
      'price': instance.price,
    };