// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'weight_man_entity.dart';

// **************************************************************************
// IsarCollectionGenerator
// **************************************************************************

// coverage:ignore-file
// ignore_for_file: duplicate_ignore, non_constant_identifier_names, constant_identifier_names, invalid_use_of_protected_member, unnecessary_cast, prefer_const_constructors, lines_longer_than_80_chars, require_trailing_commas, inference_failure_on_function_invocation, unnecessary_parenthesis, unnecessary_raw_strings, unnecessary_null_checks, join_return_with_assignment, prefer_final_locals, avoid_js_rounded_ints, avoid_positional_boolean_parameters

extension GetWeightManEntityCollection on Isar {
  IsarCollection<WeightManEntity> get weightManEntitys => this.collection();
}

const WeightManEntitySchema = CollectionSchema(
  name: r'WeightManEntity',
  id: -6134462019031877041,
  properties: {
    r'cattleresumeId': PropertySchema(
      id: 0,
      name: r'cattleresumeId',
      type: IsarType.string,
    ),
    r'createBy': PropertySchema(
      id: 1,
      name: r'createBy',
      type: IsarType.string,
    ),
    r'createTime': PropertySchema(
      id: 2,
      name: r'createTime',
      type: IsarType.string,
    ),
    r'deptId': PropertySchema(
      id: 3,
      name: r'deptId',
      type: IsarType.string,
    ),
    r'individualNo': PropertySchema(
      id: 4,
      name: r'individualNo',
      type: IsarType.string,
    ),
    r'registrationNo': PropertySchema(
      id: 5,
      name: r'registrationNo',
      type: IsarType.string,
    ),
    r'remark': PropertySchema(
      id: 6,
      name: r'remark',
      type: IsarType.string,
    ),
    r'searchValue': PropertySchema(
      id: 7,
      name: r'searchValue',
      type: IsarType.string,
    ),
    r'unid': PropertySchema(
      id: 8,
      name: r'unid',
      type: IsarType.string,
    ),
    r'updateBy': PropertySchema(
      id: 9,
      name: r'updateBy',
      type: IsarType.string,
    ),
    r'updateTime': PropertySchema(
      id: 10,
      name: r'updateTime',
      type: IsarType.string,
    ),
    r'uploadStatus': PropertySchema(
      id: 11,
      name: r'uploadStatus',
      type: IsarType.string,
    ),
    r'wTime': PropertySchema(
      id: 12,
      name: r'wTime',
      type: IsarType.string,
    ),
    r'weight': PropertySchema(
      id: 13,
      name: r'weight',
      type: IsarType.double,
    )
  },
  estimateSize: _weightManEntityEstimateSize,
  serialize: _weightManEntitySerialize,
  deserialize: _weightManEntityDeserialize,
  deserializeProp: _weightManEntityDeserializeProp,
  idName: r'id',
  indexes: {
    r'unid': IndexSchema(
      id: 4581564109674551298,
      name: r'unid',
      unique: true,
      replace: true,
      properties: [
        IndexPropertySchema(
          name: r'unid',
          type: IndexType.hash,
          caseSensitive: true,
        )
      ],
    )
  },
  links: {},
  embeddedSchemas: {},
  getId: _weightManEntityGetId,
  getLinks: _weightManEntityGetLinks,
  attach: _weightManEntityAttach,
  version: '3.0.5',
);

int _weightManEntityEstimateSize(
  WeightManEntity object,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  var bytesCount = offsets.last;
  {
    final value = object.cattleresumeId;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.createBy;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.createTime;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.deptId;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.individualNo;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.registrationNo;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.remark;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.searchValue;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.unid;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.updateBy;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.updateTime;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.uploadStatus;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.wTime;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  return bytesCount;
}

void _weightManEntitySerialize(
  WeightManEntity object,
  IsarWriter writer,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  writer.writeString(offsets[0], object.cattleresumeId);
  writer.writeString(offsets[1], object.createBy);
  writer.writeString(offsets[2], object.createTime);
  writer.writeString(offsets[3], object.deptId);
  writer.writeString(offsets[4], object.individualNo);
  writer.writeString(offsets[5], object.registrationNo);
  writer.writeString(offsets[6], object.remark);
  writer.writeString(offsets[7], object.searchValue);
  writer.writeString(offsets[8], object.unid);
  writer.writeString(offsets[9], object.updateBy);
  writer.writeString(offsets[10], object.updateTime);
  writer.writeString(offsets[11], object.uploadStatus);
  writer.writeString(offsets[12], object.wTime);
  writer.writeDouble(offsets[13], object.weight);
}

WeightManEntity _weightManEntityDeserialize(
  Id id,
  IsarReader reader,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  final object = WeightManEntity();
  object.cattleresumeId = reader.readStringOrNull(offsets[0]);
  object.createBy = reader.readStringOrNull(offsets[1]);
  object.createTime = reader.readStringOrNull(offsets[2]);
  object.deptId = reader.readStringOrNull(offsets[3]);
  object.id = id;
  object.individualNo = reader.readStringOrNull(offsets[4]);
  object.registrationNo = reader.readStringOrNull(offsets[5]);
  object.remark = reader.readStringOrNull(offsets[6]);
  object.searchValue = reader.readStringOrNull(offsets[7]);
  object.unid = reader.readStringOrNull(offsets[8]);
  object.updateBy = reader.readStringOrNull(offsets[9]);
  object.updateTime = reader.readStringOrNull(offsets[10]);
  object.uploadStatus = reader.readStringOrNull(offsets[11]);
  object.wTime = reader.readStringOrNull(offsets[12]);
  object.weight = reader.readDoubleOrNull(offsets[13]);
  return object;
}

P _weightManEntityDeserializeProp<P>(
  IsarReader reader,
  int propertyId,
  int offset,
  Map<Type, List<int>> allOffsets,
) {
  switch (propertyId) {
    case 0:
      return (reader.readStringOrNull(offset)) as P;
    case 1:
      return (reader.readStringOrNull(offset)) as P;
    case 2:
      return (reader.readStringOrNull(offset)) as P;
    case 3:
      return (reader.readStringOrNull(offset)) as P;
    case 4:
      return (reader.readStringOrNull(offset)) as P;
    case 5:
      return (reader.readStringOrNull(offset)) as P;
    case 6:
      return (reader.readStringOrNull(offset)) as P;
    case 7:
      return (reader.readStringOrNull(offset)) as P;
    case 8:
      return (reader.readStringOrNull(offset)) as P;
    case 9:
      return (reader.readStringOrNull(offset)) as P;
    case 10:
      return (reader.readStringOrNull(offset)) as P;
    case 11:
      return (reader.readStringOrNull(offset)) as P;
    case 12:
      return (reader.readStringOrNull(offset)) as P;
    case 13:
      return (reader.readDoubleOrNull(offset)) as P;
    default:
      throw IsarError('Unknown property with id $propertyId');
  }
}

Id _weightManEntityGetId(WeightManEntity object) {
  return object.id;
}

List<IsarLinkBase<dynamic>> _weightManEntityGetLinks(WeightManEntity object) {
  return [];
}

void _weightManEntityAttach(
    IsarCollection<dynamic> col, Id id, WeightManEntity object) {
  object.id = id;
}

extension WeightManEntityByIndex on IsarCollection<WeightManEntity> {
  Future<WeightManEntity?> getByUnid(String? unid) {
    return getByIndex(r'unid', [unid]);
  }

  WeightManEntity? getByUnidSync(String? unid) {
    return getByIndexSync(r'unid', [unid]);
  }

  Future<bool> deleteByUnid(String? unid) {
    return deleteByIndex(r'unid', [unid]);
  }

  bool deleteByUnidSync(String? unid) {
    return deleteByIndexSync(r'unid', [unid]);
  }

  Future<List<WeightManEntity?>> getAllByUnid(List<String?> unidValues) {
    final values = unidValues.map((e) => [e]).toList();
    return getAllByIndex(r'unid', values);
  }

  List<WeightManEntity?> getAllByUnidSync(List<String?> unidValues) {
    final values = unidValues.map((e) => [e]).toList();
    return getAllByIndexSync(r'unid', values);
  }

  Future<int> deleteAllByUnid(List<String?> unidValues) {
    final values = unidValues.map((e) => [e]).toList();
    return deleteAllByIndex(r'unid', values);
  }

  int deleteAllByUnidSync(List<String?> unidValues) {
    final values = unidValues.map((e) => [e]).toList();
    return deleteAllByIndexSync(r'unid', values);
  }

  Future<Id> putByUnid(WeightManEntity object) {
    return putByIndex(r'unid', object);
  }

  Id putByUnidSync(WeightManEntity object, {bool saveLinks = true}) {
    return putByIndexSync(r'unid', object, saveLinks: saveLinks);
  }

  Future<List<Id>> putAllByUnid(List<WeightManEntity> objects) {
    return putAllByIndex(r'unid', objects);
  }

  List<Id> putAllByUnidSync(List<WeightManEntity> objects,
      {bool saveLinks = true}) {
    return putAllByIndexSync(r'unid', objects, saveLinks: saveLinks);
  }
}

extension WeightManEntityQueryWhereSort
    on QueryBuilder<WeightManEntity, WeightManEntity, QWhere> {
  QueryBuilder<WeightManEntity, WeightManEntity, QAfterWhere> anyId() {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(const IdWhereClause.any());
    });
  }
}

extension WeightManEntityQueryWhere
    on QueryBuilder<WeightManEntity, WeightManEntity, QWhereClause> {
  QueryBuilder<WeightManEntity, WeightManEntity, QAfterWhereClause> idEqualTo(
      Id id) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IdWhereClause.between(
        lower: id,
        upper: id,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterWhereClause>
      idNotEqualTo(Id id) {
    return QueryBuilder.apply(this, (query) {
      if (query.whereSort == Sort.asc) {
        return query
            .addWhereClause(
              IdWhereClause.lessThan(upper: id, includeUpper: false),
            )
            .addWhereClause(
              IdWhereClause.greaterThan(lower: id, includeLower: false),
            );
      } else {
        return query
            .addWhereClause(
              IdWhereClause.greaterThan(lower: id, includeLower: false),
            )
            .addWhereClause(
              IdWhereClause.lessThan(upper: id, includeUpper: false),
            );
      }
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterWhereClause>
      idGreaterThan(Id id, {bool include = false}) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(
        IdWhereClause.greaterThan(lower: id, includeLower: include),
      );
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterWhereClause> idLessThan(
      Id id,
      {bool include = false}) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(
        IdWhereClause.lessThan(upper: id, includeUpper: include),
      );
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterWhereClause> idBetween(
    Id lowerId,
    Id upperId, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IdWhereClause.between(
        lower: lowerId,
        includeLower: includeLower,
        upper: upperId,
        includeUpper: includeUpper,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterWhereClause>
      unidIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.equalTo(
        indexName: r'unid',
        value: [null],
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterWhereClause>
      unidIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'unid',
        lower: [null],
        includeLower: false,
        upper: [],
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterWhereClause> unidEqualTo(
      String? unid) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.equalTo(
        indexName: r'unid',
        value: [unid],
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterWhereClause>
      unidNotEqualTo(String? unid) {
    return QueryBuilder.apply(this, (query) {
      if (query.whereSort == Sort.asc) {
        return query
            .addWhereClause(IndexWhereClause.between(
              indexName: r'unid',
              lower: [],
              upper: [unid],
              includeUpper: false,
            ))
            .addWhereClause(IndexWhereClause.between(
              indexName: r'unid',
              lower: [unid],
              includeLower: false,
              upper: [],
            ));
      } else {
        return query
            .addWhereClause(IndexWhereClause.between(
              indexName: r'unid',
              lower: [unid],
              includeLower: false,
              upper: [],
            ))
            .addWhereClause(IndexWhereClause.between(
              indexName: r'unid',
              lower: [],
              upper: [unid],
              includeUpper: false,
            ));
      }
    });
  }
}

extension WeightManEntityQueryFilter
    on QueryBuilder<WeightManEntity, WeightManEntity, QFilterCondition> {
  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      cattleresumeIdIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'cattleresumeId',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      cattleresumeIdIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'cattleresumeId',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      cattleresumeIdEqualTo(
    String? value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'cattleresumeId',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      cattleresumeIdGreaterThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'cattleresumeId',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      cattleresumeIdLessThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'cattleresumeId',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      cattleresumeIdBetween(
    String? lower,
    String? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'cattleresumeId',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      cattleresumeIdStartsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.startsWith(
        property: r'cattleresumeId',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      cattleresumeIdEndsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.endsWith(
        property: r'cattleresumeId',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      cattleresumeIdContains(String value, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.contains(
        property: r'cattleresumeId',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      cattleresumeIdMatches(String pattern, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.matches(
        property: r'cattleresumeId',
        wildcard: pattern,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      cattleresumeIdIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'cattleresumeId',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      cattleresumeIdIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'cattleresumeId',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createByIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'createBy',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createByIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'createBy',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createByEqualTo(
    String? value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'createBy',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createByGreaterThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'createBy',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createByLessThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'createBy',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createByBetween(
    String? lower,
    String? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'createBy',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createByStartsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.startsWith(
        property: r'createBy',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createByEndsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.endsWith(
        property: r'createBy',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createByContains(String value, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.contains(
        property: r'createBy',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createByMatches(String pattern, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.matches(
        property: r'createBy',
        wildcard: pattern,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createByIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'createBy',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createByIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'createBy',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createTimeIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'createTime',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createTimeIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'createTime',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createTimeEqualTo(
    String? value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'createTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createTimeGreaterThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'createTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createTimeLessThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'createTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createTimeBetween(
    String? lower,
    String? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'createTime',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createTimeStartsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.startsWith(
        property: r'createTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createTimeEndsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.endsWith(
        property: r'createTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createTimeContains(String value, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.contains(
        property: r'createTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createTimeMatches(String pattern, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.matches(
        property: r'createTime',
        wildcard: pattern,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createTimeIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'createTime',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      createTimeIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'createTime',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      deptIdIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'deptId',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      deptIdIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'deptId',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      deptIdEqualTo(
    String? value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'deptId',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      deptIdGreaterThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'deptId',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      deptIdLessThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'deptId',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      deptIdBetween(
    String? lower,
    String? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'deptId',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      deptIdStartsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.startsWith(
        property: r'deptId',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      deptIdEndsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.endsWith(
        property: r'deptId',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      deptIdContains(String value, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.contains(
        property: r'deptId',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      deptIdMatches(String pattern, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.matches(
        property: r'deptId',
        wildcard: pattern,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      deptIdIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'deptId',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      deptIdIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'deptId',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      idEqualTo(Id value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'id',
        value: value,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      idGreaterThan(
    Id value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'id',
        value: value,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      idLessThan(
    Id value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'id',
        value: value,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      idBetween(
    Id lower,
    Id upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'id',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      individualNoIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'individualNo',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      individualNoIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'individualNo',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      individualNoEqualTo(
    String? value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'individualNo',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      individualNoGreaterThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'individualNo',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      individualNoLessThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'individualNo',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      individualNoBetween(
    String? lower,
    String? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'individualNo',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      individualNoStartsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.startsWith(
        property: r'individualNo',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      individualNoEndsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.endsWith(
        property: r'individualNo',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      individualNoContains(String value, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.contains(
        property: r'individualNo',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      individualNoMatches(String pattern, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.matches(
        property: r'individualNo',
        wildcard: pattern,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      individualNoIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'individualNo',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      individualNoIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'individualNo',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      registrationNoIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'registrationNo',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      registrationNoIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'registrationNo',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      registrationNoEqualTo(
    String? value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'registrationNo',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      registrationNoGreaterThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'registrationNo',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      registrationNoLessThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'registrationNo',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      registrationNoBetween(
    String? lower,
    String? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'registrationNo',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      registrationNoStartsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.startsWith(
        property: r'registrationNo',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      registrationNoEndsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.endsWith(
        property: r'registrationNo',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      registrationNoContains(String value, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.contains(
        property: r'registrationNo',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      registrationNoMatches(String pattern, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.matches(
        property: r'registrationNo',
        wildcard: pattern,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      registrationNoIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'registrationNo',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      registrationNoIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'registrationNo',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      remarkIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'remark',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      remarkIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'remark',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      remarkEqualTo(
    String? value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'remark',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      remarkGreaterThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'remark',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      remarkLessThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'remark',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      remarkBetween(
    String? lower,
    String? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'remark',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      remarkStartsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.startsWith(
        property: r'remark',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      remarkEndsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.endsWith(
        property: r'remark',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      remarkContains(String value, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.contains(
        property: r'remark',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      remarkMatches(String pattern, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.matches(
        property: r'remark',
        wildcard: pattern,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      remarkIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'remark',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      remarkIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'remark',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      searchValueIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'searchValue',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      searchValueIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'searchValue',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      searchValueEqualTo(
    String? value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'searchValue',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      searchValueGreaterThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'searchValue',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      searchValueLessThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'searchValue',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      searchValueBetween(
    String? lower,
    String? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'searchValue',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      searchValueStartsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.startsWith(
        property: r'searchValue',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      searchValueEndsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.endsWith(
        property: r'searchValue',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      searchValueContains(String value, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.contains(
        property: r'searchValue',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      searchValueMatches(String pattern, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.matches(
        property: r'searchValue',
        wildcard: pattern,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      searchValueIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'searchValue',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      searchValueIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'searchValue',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      unidIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'unid',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      unidIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'unid',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      unidEqualTo(
    String? value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'unid',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      unidGreaterThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'unid',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      unidLessThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'unid',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      unidBetween(
    String? lower,
    String? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'unid',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      unidStartsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.startsWith(
        property: r'unid',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      unidEndsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.endsWith(
        property: r'unid',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      unidContains(String value, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.contains(
        property: r'unid',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      unidMatches(String pattern, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.matches(
        property: r'unid',
        wildcard: pattern,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      unidIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'unid',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      unidIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'unid',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateByIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'updateBy',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateByIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'updateBy',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateByEqualTo(
    String? value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'updateBy',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateByGreaterThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'updateBy',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateByLessThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'updateBy',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateByBetween(
    String? lower,
    String? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'updateBy',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateByStartsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.startsWith(
        property: r'updateBy',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateByEndsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.endsWith(
        property: r'updateBy',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateByContains(String value, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.contains(
        property: r'updateBy',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateByMatches(String pattern, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.matches(
        property: r'updateBy',
        wildcard: pattern,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateByIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'updateBy',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateByIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'updateBy',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateTimeIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'updateTime',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateTimeIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'updateTime',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateTimeEqualTo(
    String? value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'updateTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateTimeGreaterThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'updateTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateTimeLessThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'updateTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateTimeBetween(
    String? lower,
    String? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'updateTime',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateTimeStartsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.startsWith(
        property: r'updateTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateTimeEndsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.endsWith(
        property: r'updateTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateTimeContains(String value, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.contains(
        property: r'updateTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateTimeMatches(String pattern, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.matches(
        property: r'updateTime',
        wildcard: pattern,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateTimeIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'updateTime',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      updateTimeIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'updateTime',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      uploadStatusIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'uploadStatus',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      uploadStatusIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'uploadStatus',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      uploadStatusEqualTo(
    String? value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'uploadStatus',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      uploadStatusGreaterThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'uploadStatus',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      uploadStatusLessThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'uploadStatus',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      uploadStatusBetween(
    String? lower,
    String? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'uploadStatus',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      uploadStatusStartsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.startsWith(
        property: r'uploadStatus',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      uploadStatusEndsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.endsWith(
        property: r'uploadStatus',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      uploadStatusContains(String value, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.contains(
        property: r'uploadStatus',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      uploadStatusMatches(String pattern, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.matches(
        property: r'uploadStatus',
        wildcard: pattern,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      uploadStatusIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'uploadStatus',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      uploadStatusIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'uploadStatus',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      wTimeIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'wTime',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      wTimeIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'wTime',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      wTimeEqualTo(
    String? value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'wTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      wTimeGreaterThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'wTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      wTimeLessThan(
    String? value, {
    bool include = false,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'wTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      wTimeBetween(
    String? lower,
    String? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'wTime',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      wTimeStartsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.startsWith(
        property: r'wTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      wTimeEndsWith(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.endsWith(
        property: r'wTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      wTimeContains(String value, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.contains(
        property: r'wTime',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      wTimeMatches(String pattern, {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.matches(
        property: r'wTime',
        wildcard: pattern,
        caseSensitive: caseSensitive,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      wTimeIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'wTime',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      wTimeIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'wTime',
        value: '',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      weightIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'weight',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      weightIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'weight',
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      weightEqualTo(
    double? value, {
    double epsilon = Query.epsilon,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'weight',
        value: value,
        epsilon: epsilon,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      weightGreaterThan(
    double? value, {
    bool include = false,
    double epsilon = Query.epsilon,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'weight',
        value: value,
        epsilon: epsilon,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      weightLessThan(
    double? value, {
    bool include = false,
    double epsilon = Query.epsilon,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'weight',
        value: value,
        epsilon: epsilon,
      ));
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterFilterCondition>
      weightBetween(
    double? lower,
    double? upper, {
    bool includeLower = true,
    bool includeUpper = true,
    double epsilon = Query.epsilon,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'weight',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        epsilon: epsilon,
      ));
    });
  }
}

extension WeightManEntityQueryObject
    on QueryBuilder<WeightManEntity, WeightManEntity, QFilterCondition> {}

extension WeightManEntityQueryLinks
    on QueryBuilder<WeightManEntity, WeightManEntity, QFilterCondition> {}

extension WeightManEntityQuerySortBy
    on QueryBuilder<WeightManEntity, WeightManEntity, QSortBy> {
  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByCattleresumeId() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'cattleresumeId', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByCattleresumeIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'cattleresumeId', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByCreateBy() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createBy', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByCreateByDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createBy', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByCreateTime() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createTime', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByCreateTimeDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createTime', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy> sortByDeptId() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'deptId', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByDeptIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'deptId', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByIndividualNo() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'individualNo', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByIndividualNoDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'individualNo', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByRegistrationNo() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'registrationNo', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByRegistrationNoDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'registrationNo', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy> sortByRemark() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'remark', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByRemarkDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'remark', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortBySearchValue() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'searchValue', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortBySearchValueDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'searchValue', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy> sortByUnid() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'unid', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByUnidDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'unid', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByUpdateBy() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updateBy', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByUpdateByDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updateBy', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByUpdateTime() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updateTime', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByUpdateTimeDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updateTime', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByUploadStatus() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'uploadStatus', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByUploadStatusDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'uploadStatus', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy> sortByWTime() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'wTime', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByWTimeDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'wTime', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy> sortByWeight() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'weight', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      sortByWeightDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'weight', Sort.desc);
    });
  }
}

extension WeightManEntityQuerySortThenBy
    on QueryBuilder<WeightManEntity, WeightManEntity, QSortThenBy> {
  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByCattleresumeId() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'cattleresumeId', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByCattleresumeIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'cattleresumeId', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByCreateBy() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createBy', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByCreateByDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createBy', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByCreateTime() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createTime', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByCreateTimeDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createTime', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy> thenByDeptId() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'deptId', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByDeptIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'deptId', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy> thenById() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'id', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy> thenByIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'id', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByIndividualNo() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'individualNo', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByIndividualNoDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'individualNo', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByRegistrationNo() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'registrationNo', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByRegistrationNoDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'registrationNo', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy> thenByRemark() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'remark', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByRemarkDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'remark', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenBySearchValue() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'searchValue', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenBySearchValueDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'searchValue', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy> thenByUnid() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'unid', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByUnidDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'unid', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByUpdateBy() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updateBy', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByUpdateByDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updateBy', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByUpdateTime() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updateTime', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByUpdateTimeDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updateTime', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByUploadStatus() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'uploadStatus', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByUploadStatusDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'uploadStatus', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy> thenByWTime() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'wTime', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByWTimeDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'wTime', Sort.desc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy> thenByWeight() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'weight', Sort.asc);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QAfterSortBy>
      thenByWeightDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'weight', Sort.desc);
    });
  }
}

extension WeightManEntityQueryWhereDistinct
    on QueryBuilder<WeightManEntity, WeightManEntity, QDistinct> {
  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct>
      distinctByCattleresumeId({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'cattleresumeId',
          caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct> distinctByCreateBy(
      {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'createBy', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct>
      distinctByCreateTime({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'createTime', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct> distinctByDeptId(
      {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'deptId', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct>
      distinctByIndividualNo({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'individualNo', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct>
      distinctByRegistrationNo({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'registrationNo',
          caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct> distinctByRemark(
      {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'remark', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct>
      distinctBySearchValue({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'searchValue', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct> distinctByUnid(
      {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'unid', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct> distinctByUpdateBy(
      {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'updateBy', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct>
      distinctByUpdateTime({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'updateTime', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct>
      distinctByUploadStatus({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'uploadStatus', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct> distinctByWTime(
      {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'wTime', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<WeightManEntity, WeightManEntity, QDistinct> distinctByWeight() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'weight');
    });
  }
}

extension WeightManEntityQueryProperty
    on QueryBuilder<WeightManEntity, WeightManEntity, QQueryProperty> {
  QueryBuilder<WeightManEntity, int, QQueryOperations> idProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'id');
    });
  }

  QueryBuilder<WeightManEntity, String?, QQueryOperations>
      cattleresumeIdProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'cattleresumeId');
    });
  }

  QueryBuilder<WeightManEntity, String?, QQueryOperations> createByProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'createBy');
    });
  }

  QueryBuilder<WeightManEntity, String?, QQueryOperations>
      createTimeProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'createTime');
    });
  }

  QueryBuilder<WeightManEntity, String?, QQueryOperations> deptIdProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'deptId');
    });
  }

  QueryBuilder<WeightManEntity, String?, QQueryOperations>
      individualNoProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'individualNo');
    });
  }

  QueryBuilder<WeightManEntity, String?, QQueryOperations>
      registrationNoProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'registrationNo');
    });
  }

  QueryBuilder<WeightManEntity, String?, QQueryOperations> remarkProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'remark');
    });
  }

  QueryBuilder<WeightManEntity, String?, QQueryOperations>
      searchValueProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'searchValue');
    });
  }

  QueryBuilder<WeightManEntity, String?, QQueryOperations> unidProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'unid');
    });
  }

  QueryBuilder<WeightManEntity, String?, QQueryOperations> updateByProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'updateBy');
    });
  }

  QueryBuilder<WeightManEntity, String?, QQueryOperations>
      updateTimeProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'updateTime');
    });
  }

  QueryBuilder<WeightManEntity, String?, QQueryOperations>
      uploadStatusProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'uploadStatus');
    });
  }

  QueryBuilder<WeightManEntity, String?, QQueryOperations> wTimeProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'wTime');
    });
  }

  QueryBuilder<WeightManEntity, double?, QQueryOperations> weightProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'weight');
    });
  }
}
