// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'journal_entry_collection.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, always_specify_types

extension GetJournalEntryCollectionCollection on Isar {
  IsarCollection<JournalEntryCollection> get journalEntryCollections =>
      this.collection();
}

const JournalEntryCollectionSchema = CollectionSchema(
  name: r'JournalEntryCollection',
  id: -6325316395299921961,
  properties: {
    r'assignedTopicId': PropertySchema(
      id: 0,
      name: r'assignedTopicId',
      type: IsarType.string,
    ),
    r'authorId': PropertySchema(
      id: 1,
      name: r'authorId',
      type: IsarType.string,
    ),
    r'classId': PropertySchema(
      id: 2,
      name: r'classId',
      type: IsarType.string,
    ),
    r'contentExcerpt': PropertySchema(
      id: 3,
      name: r'contentExcerpt',
      type: IsarType.string,
    ),
    r'createdAtEpoch': PropertySchema(
      id: 4,
      name: r'createdAtEpoch',
      type: IsarType.long,
    ),
    r'dateEpoch': PropertySchema(
      id: 5,
      name: r'dateEpoch',
      type: IsarType.long,
    ),
    r'id': PropertySchema(
      id: 6,
      name: r'id',
      type: IsarType.string,
    ),
    r'isDeleted': PropertySchema(
      id: 7,
      name: r'isDeleted',
      type: IsarType.bool,
    ),
    r'isPrivate': PropertySchema(
      id: 8,
      name: r'isPrivate',
      type: IsarType.bool,
    ),
    r'mood': PropertySchema(
      id: 9,
      name: r'mood',
      type: IsarType.string,
    ),
    r'sharedToClass': PropertySchema(
      id: 10,
      name: r'sharedToClass',
      type: IsarType.bool,
    ),
    r'tagsJson': PropertySchema(
      id: 11,
      name: r'tagsJson',
      type: IsarType.string,
    ),
    r'title': PropertySchema(
      id: 12,
      name: r'title',
      type: IsarType.string,
    ),
    r'updatedAtEpoch': PropertySchema(
      id: 13,
      name: r'updatedAtEpoch',
      type: IsarType.long,
    ),
    r'version': PropertySchema(
      id: 14,
      name: r'version',
      type: IsarType.long,
    ),
    r'weather': PropertySchema(
      id: 15,
      name: r'weather',
      type: IsarType.string,
    )
  },
  estimateSize: _journalEntryCollectionEstimateSize,
  serialize: _journalEntryCollectionSerialize,
  deserialize: _journalEntryCollectionDeserialize,
  deserializeProp: _journalEntryCollectionDeserializeProp,
  idName: r'isarId',
  indexes: {
    r'id': IndexSchema(
      id: -3268401673993471357,
      name: r'id',
      unique: false,
      replace: false,
      properties: [
        IndexPropertySchema(
          name: r'id',
          type: IndexType.hash,
          caseSensitive: true,
        )
      ],
    ),
    r'authorId_dateEpoch': IndexSchema(
      id: -4869847655132214108,
      name: r'authorId_dateEpoch',
      unique: false,
      replace: false,
      properties: [
        IndexPropertySchema(
          name: r'authorId',
          type: IndexType.hash,
          caseSensitive: true,
        ),
        IndexPropertySchema(
          name: r'dateEpoch',
          type: IndexType.value,
          caseSensitive: false,
        )
      ],
    ),
    r'dateEpoch': IndexSchema(
      id: 359017825055613028,
      name: r'dateEpoch',
      unique: false,
      replace: false,
      properties: [
        IndexPropertySchema(
          name: r'dateEpoch',
          type: IndexType.value,
          caseSensitive: false,
        )
      ],
    )
  },
  links: {},
  embeddedSchemas: {},
  getId: _journalEntryCollectionGetId,
  getLinks: _journalEntryCollectionGetLinks,
  attach: _journalEntryCollectionAttach,
  version: '3.1.0+1',
);

int _journalEntryCollectionEstimateSize(
  JournalEntryCollection object,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  var bytesCount = offsets.last;
  {
    final value = object.assignedTopicId;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  bytesCount += 3 + object.authorId.length * 3;
  {
    final value = object.classId;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.contentExcerpt;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  bytesCount += 3 + object.id.length * 3;
  bytesCount += 3 + object.mood.length * 3;
  bytesCount += 3 + object.tagsJson.length * 3;
  bytesCount += 3 + object.title.length * 3;
  bytesCount += 3 + object.weather.length * 3;
  return bytesCount;
}

void _journalEntryCollectionSerialize(
  JournalEntryCollection object,
  IsarWriter writer,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  writer.writeString(offsets[0], object.assignedTopicId);
  writer.writeString(offsets[1], object.authorId);
  writer.writeString(offsets[2], object.classId);
  writer.writeString(offsets[3], object.contentExcerpt);
  writer.writeLong(offsets[4], object.createdAtEpoch);
  writer.writeLong(offsets[5], object.dateEpoch);
  writer.writeString(offsets[6], object.id);
  writer.writeBool(offsets[7], object.isDeleted);
  writer.writeBool(offsets[8], object.isPrivate);
  writer.writeString(offsets[9], object.mood);
  writer.writeBool(offsets[10], object.sharedToClass);
  writer.writeString(offsets[11], object.tagsJson);
  writer.writeString(offsets[12], object.title);
  writer.writeLong(offsets[13], object.updatedAtEpoch);
  writer.writeLong(offsets[14], object.version);
  writer.writeString(offsets[15], object.weather);
}

JournalEntryCollection _journalEntryCollectionDeserialize(
  Id id,
  IsarReader reader,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  final object = JournalEntryCollection();
  object.assignedTopicId = reader.readStringOrNull(offsets[0]);
  object.authorId = reader.readString(offsets[1]);
  object.classId = reader.readStringOrNull(offsets[2]);
  object.contentExcerpt = reader.readStringOrNull(offsets[3]);
  object.createdAtEpoch = reader.readLong(offsets[4]);
  object.dateEpoch = reader.readLong(offsets[5]);
  object.id = reader.readString(offsets[6]);
  object.isDeleted = reader.readBool(offsets[7]);
  object.isPrivate = reader.readBool(offsets[8]);
  object.isarId = id;
  object.mood = reader.readString(offsets[9]);
  object.sharedToClass = reader.readBool(offsets[10]);
  object.tagsJson = reader.readString(offsets[11]);
  object.title = reader.readString(offsets[12]);
  object.updatedAtEpoch = reader.readLong(offsets[13]);
  object.version = reader.readLong(offsets[14]);
  object.weather = reader.readString(offsets[15]);
  return object;
}

P _journalEntryCollectionDeserializeProp<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.readString(offset)) as P;
    case 2:
      return (reader.readStringOrNull(offset)) as P;
    case 3:
      return (reader.readStringOrNull(offset)) as P;
    case 4:
      return (reader.readLong(offset)) as P;
    case 5:
      return (reader.readLong(offset)) as P;
    case 6:
      return (reader.readString(offset)) as P;
    case 7:
      return (reader.readBool(offset)) as P;
    case 8:
      return (reader.readBool(offset)) as P;
    case 9:
      return (reader.readString(offset)) as P;
    case 10:
      return (reader.readBool(offset)) as P;
    case 11:
      return (reader.readString(offset)) as P;
    case 12:
      return (reader.readString(offset)) as P;
    case 13:
      return (reader.readLong(offset)) as P;
    case 14:
      return (reader.readLong(offset)) as P;
    case 15:
      return (reader.readString(offset)) as P;
    default:
      throw IsarError('Unknown property with id $propertyId');
  }
}

Id _journalEntryCollectionGetId(JournalEntryCollection object) {
  return object.isarId;
}

List<IsarLinkBase<dynamic>> _journalEntryCollectionGetLinks(
    JournalEntryCollection object) {
  return [];
}

void _journalEntryCollectionAttach(
    IsarCollection<dynamic> col, Id id, JournalEntryCollection object) {
  object.isarId = id;
}

extension JournalEntryCollectionQueryWhereSort
    on QueryBuilder<JournalEntryCollection, JournalEntryCollection, QWhere> {
  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterWhere>
      anyIsarId() {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(const IdWhereClause.any());
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterWhere>
      anyDateEpoch() {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(
        const IndexWhereClause.any(indexName: r'dateEpoch'),
      );
    });
  }
}

extension JournalEntryCollectionQueryWhere on QueryBuilder<
    JournalEntryCollection, JournalEntryCollection, QWhereClause> {
  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterWhereClause> isarIdEqualTo(Id isarId) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IdWhereClause.between(
        lower: isarId,
        upper: isarId,
      ));
    });
  }

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterWhereClause> isarIdBetween(
    Id lowerIsarId,
    Id upperIsarId, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IdWhereClause.between(
        lower: lowerIsarId,
        includeLower: includeLower,
        upper: upperIsarId,
        includeUpper: includeUpper,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterWhereClause> idEqualTo(String id) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.equalTo(
        indexName: r'id',
        value: [id],
      ));
    });
  }

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterWhereClause> authorIdEqualToAnyDateEpoch(String authorId) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.equalTo(
        indexName: r'authorId_dateEpoch',
        value: [authorId],
      ));
    });
  }

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
          QAfterWhereClause>
      authorIdDateEpochEqualTo(String authorId, int dateEpoch) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.equalTo(
        indexName: r'authorId_dateEpoch',
        value: [authorId, dateEpoch],
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
          QAfterWhereClause>
      authorIdEqualToDateEpochNotEqualTo(String authorId, int dateEpoch) {
    return QueryBuilder.apply(this, (query) {
      if (query.whereSort == Sort.asc) {
        return query
            .addWhereClause(IndexWhereClause.between(
              indexName: r'authorId_dateEpoch',
              lower: [authorId],
              upper: [authorId, dateEpoch],
              includeUpper: false,
            ))
            .addWhereClause(IndexWhereClause.between(
              indexName: r'authorId_dateEpoch',
              lower: [authorId, dateEpoch],
              includeLower: false,
              upper: [authorId],
            ));
      } else {
        return query
            .addWhereClause(IndexWhereClause.between(
              indexName: r'authorId_dateEpoch',
              lower: [authorId, dateEpoch],
              includeLower: false,
              upper: [authorId],
            ))
            .addWhereClause(IndexWhereClause.between(
              indexName: r'authorId_dateEpoch',
              lower: [authorId],
              upper: [authorId, dateEpoch],
              includeUpper: false,
            ));
      }
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterWhereClause> authorIdEqualToDateEpochGreaterThan(
    String authorId,
    int dateEpoch, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'authorId_dateEpoch',
        lower: [authorId, dateEpoch],
        includeLower: include,
        upper: [authorId],
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterWhereClause> authorIdEqualToDateEpochLessThan(
    String authorId,
    int dateEpoch, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'authorId_dateEpoch',
        lower: [authorId],
        upper: [authorId, dateEpoch],
        includeUpper: include,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterWhereClause> authorIdEqualToDateEpochBetween(
    String authorId,
    int lowerDateEpoch,
    int upperDateEpoch, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'authorId_dateEpoch',
        lower: [authorId, lowerDateEpoch],
        includeLower: includeLower,
        upper: [authorId, upperDateEpoch],
        includeUpper: includeUpper,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterWhereClause> dateEpochEqualTo(int dateEpoch) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.equalTo(
        indexName: r'dateEpoch',
        value: [dateEpoch],
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterWhereClause> dateEpochNotEqualTo(int dateEpoch) {
    return QueryBuilder.apply(this, (query) {
      if (query.whereSort == Sort.asc) {
        return query
            .addWhereClause(IndexWhereClause.between(
              indexName: r'dateEpoch',
              lower: [],
              upper: [dateEpoch],
              includeUpper: false,
            ))
            .addWhereClause(IndexWhereClause.between(
              indexName: r'dateEpoch',
              lower: [dateEpoch],
              includeLower: false,
              upper: [],
            ));
      } else {
        return query
            .addWhereClause(IndexWhereClause.between(
              indexName: r'dateEpoch',
              lower: [dateEpoch],
              includeLower: false,
              upper: [],
            ))
            .addWhereClause(IndexWhereClause.between(
              indexName: r'dateEpoch',
              lower: [],
              upper: [dateEpoch],
              includeUpper: false,
            ));
      }
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterWhereClause> dateEpochGreaterThan(
    int dateEpoch, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'dateEpoch',
        lower: [dateEpoch],
        includeLower: include,
        upper: [],
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterWhereClause> dateEpochLessThan(
    int dateEpoch, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'dateEpoch',
        lower: [],
        upper: [dateEpoch],
        includeUpper: include,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterWhereClause> dateEpochBetween(
    int lowerDateEpoch,
    int upperDateEpoch, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'dateEpoch',
        lower: [lowerDateEpoch],
        includeLower: includeLower,
        upper: [upperDateEpoch],
        includeUpper: includeUpper,
      ));
    });
  }
}

extension JournalEntryCollectionQueryFilter on QueryBuilder<
    JournalEntryCollection, JournalEntryCollection, QFilterCondition> {
  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> assignedTopicIdIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'assignedTopicId',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> assignedTopicIdIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'assignedTopicId',
      ));
    });
  }

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> assignedTopicIdBetween(
    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'assignedTopicId',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> assignedTopicIdIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'assignedTopicId',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> assignedTopicIdIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'assignedTopicId',
        value: '',
      ));
    });
  }

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> authorIdBetween(
    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'authorId',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> authorIdIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'authorId',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> authorIdIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'authorId',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> classIdIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'classId',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> classIdIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'classId',
      ));
    });
  }

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> classIdBetween(
    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'classId',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> classIdIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'classId',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> classIdIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'classId',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> contentExcerptIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'contentExcerpt',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> contentExcerptIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'contentExcerpt',
      ));
    });
  }

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> contentExcerptBetween(
    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'contentExcerpt',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> contentExcerptIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'contentExcerpt',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> contentExcerptIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'contentExcerpt',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> createdAtEpochEqualTo(int value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'createdAtEpoch',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> createdAtEpochGreaterThan(
    int value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'createdAtEpoch',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> createdAtEpochLessThan(
    int value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'createdAtEpoch',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> createdAtEpochBetween(
    int lower,
    int upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'createdAtEpoch',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> dateEpochEqualTo(int value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'dateEpoch',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> dateEpochGreaterThan(
    int value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'dateEpoch',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> dateEpochLessThan(
    int value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'dateEpoch',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> dateEpochBetween(
    int lower,
    int upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'dateEpoch',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
      ));
    });
  }

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> idBetween(
    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'id',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> idIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'id',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> isDeletedEqualTo(bool value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'isDeleted',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> isPrivateEqualTo(bool value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'isPrivate',
        value: value,
      ));
    });
  }

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

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

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

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

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> moodBetween(
    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'mood',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> moodIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'mood',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> moodIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'mood',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> sharedToClassEqualTo(bool value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'sharedToClass',
        value: value,
      ));
    });
  }

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> tagsJsonBetween(
    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'tagsJson',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> tagsJsonIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'tagsJson',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> tagsJsonIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'tagsJson',
        value: '',
      ));
    });
  }

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> titleBetween(
    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'title',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> titleIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'title',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> titleIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'title',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> updatedAtEpochEqualTo(int value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'updatedAtEpoch',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> updatedAtEpochGreaterThan(
    int value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'updatedAtEpoch',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> updatedAtEpochLessThan(
    int value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'updatedAtEpoch',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> updatedAtEpochBetween(
    int lower,
    int upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'updatedAtEpoch',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> versionEqualTo(int value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'version',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> versionGreaterThan(
    int value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'version',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> versionLessThan(
    int value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'version',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> versionBetween(
    int lower,
    int upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'version',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
      ));
    });
  }

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> weatherBetween(
    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'weather',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> weatherIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'weather',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection,
      QAfterFilterCondition> weatherIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'weather',
        value: '',
      ));
    });
  }
}

extension JournalEntryCollectionQueryObject on QueryBuilder<
    JournalEntryCollection, JournalEntryCollection, QFilterCondition> {}

extension JournalEntryCollectionQueryLinks on QueryBuilder<
    JournalEntryCollection, JournalEntryCollection, QFilterCondition> {}

extension JournalEntryCollectionQuerySortBy
    on QueryBuilder<JournalEntryCollection, JournalEntryCollection, QSortBy> {
  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByAssignedTopicId() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'assignedTopicId', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByAssignedTopicIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'assignedTopicId', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByAuthorId() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'authorId', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByAuthorIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'authorId', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByClassId() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'classId', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByClassIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'classId', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByContentExcerpt() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'contentExcerpt', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByContentExcerptDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'contentExcerpt', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByCreatedAtEpoch() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createdAtEpoch', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByCreatedAtEpochDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createdAtEpoch', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByDateEpoch() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'dateEpoch', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByDateEpochDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'dateEpoch', Sort.desc);
    });
  }

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByIsDeleted() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isDeleted', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByIsDeletedDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isDeleted', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByIsPrivate() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isPrivate', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByIsPrivateDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isPrivate', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByMood() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'mood', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByMoodDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'mood', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortBySharedToClass() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'sharedToClass', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortBySharedToClassDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'sharedToClass', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByTagsJson() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'tagsJson', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByTagsJsonDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'tagsJson', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByTitle() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'title', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByTitleDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'title', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByUpdatedAtEpoch() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updatedAtEpoch', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByUpdatedAtEpochDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updatedAtEpoch', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByVersion() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'version', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByVersionDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'version', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByWeather() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'weather', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      sortByWeatherDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'weather', Sort.desc);
    });
  }
}

extension JournalEntryCollectionQuerySortThenBy on QueryBuilder<
    JournalEntryCollection, JournalEntryCollection, QSortThenBy> {
  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByAssignedTopicId() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'assignedTopicId', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByAssignedTopicIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'assignedTopicId', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByAuthorId() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'authorId', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByAuthorIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'authorId', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByClassId() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'classId', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByClassIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'classId', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByContentExcerpt() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'contentExcerpt', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByContentExcerptDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'contentExcerpt', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByCreatedAtEpoch() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createdAtEpoch', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByCreatedAtEpochDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createdAtEpoch', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByDateEpoch() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'dateEpoch', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByDateEpochDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'dateEpoch', Sort.desc);
    });
  }

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

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

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByIsDeleted() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isDeleted', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByIsDeletedDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isDeleted', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByIsPrivate() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isPrivate', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByIsPrivateDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isPrivate', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByIsarId() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isarId', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByIsarIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isarId', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByMood() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'mood', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByMoodDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'mood', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenBySharedToClass() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'sharedToClass', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenBySharedToClassDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'sharedToClass', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByTagsJson() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'tagsJson', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByTagsJsonDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'tagsJson', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByTitle() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'title', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByTitleDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'title', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByUpdatedAtEpoch() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updatedAtEpoch', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByUpdatedAtEpochDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updatedAtEpoch', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByVersion() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'version', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByVersionDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'version', Sort.desc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByWeather() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'weather', Sort.asc);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QAfterSortBy>
      thenByWeatherDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'weather', Sort.desc);
    });
  }
}

extension JournalEntryCollectionQueryWhereDistinct
    on QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct> {
  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByAssignedTopicId({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'assignedTopicId',
          caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByAuthorId({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'authorId', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByClassId({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'classId', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByContentExcerpt({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'contentExcerpt',
          caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByCreatedAtEpoch() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'createdAtEpoch');
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByDateEpoch() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'dateEpoch');
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctById({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'id', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByIsDeleted() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'isDeleted');
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByIsPrivate() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'isPrivate');
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByMood({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'mood', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctBySharedToClass() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'sharedToClass');
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByTagsJson({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'tagsJson', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByTitle({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'title', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByUpdatedAtEpoch() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'updatedAtEpoch');
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByVersion() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'version');
    });
  }

  QueryBuilder<JournalEntryCollection, JournalEntryCollection, QDistinct>
      distinctByWeather({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'weather', caseSensitive: caseSensitive);
    });
  }
}

extension JournalEntryCollectionQueryProperty on QueryBuilder<
    JournalEntryCollection, JournalEntryCollection, QQueryProperty> {
  QueryBuilder<JournalEntryCollection, int, QQueryOperations> isarIdProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'isarId');
    });
  }

  QueryBuilder<JournalEntryCollection, String?, QQueryOperations>
      assignedTopicIdProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'assignedTopicId');
    });
  }

  QueryBuilder<JournalEntryCollection, String, QQueryOperations>
      authorIdProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'authorId');
    });
  }

  QueryBuilder<JournalEntryCollection, String?, QQueryOperations>
      classIdProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'classId');
    });
  }

  QueryBuilder<JournalEntryCollection, String?, QQueryOperations>
      contentExcerptProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'contentExcerpt');
    });
  }

  QueryBuilder<JournalEntryCollection, int, QQueryOperations>
      createdAtEpochProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'createdAtEpoch');
    });
  }

  QueryBuilder<JournalEntryCollection, int, QQueryOperations>
      dateEpochProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'dateEpoch');
    });
  }

  QueryBuilder<JournalEntryCollection, String, QQueryOperations> idProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'id');
    });
  }

  QueryBuilder<JournalEntryCollection, bool, QQueryOperations>
      isDeletedProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'isDeleted');
    });
  }

  QueryBuilder<JournalEntryCollection, bool, QQueryOperations>
      isPrivateProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'isPrivate');
    });
  }

  QueryBuilder<JournalEntryCollection, String, QQueryOperations>
      moodProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'mood');
    });
  }

  QueryBuilder<JournalEntryCollection, bool, QQueryOperations>
      sharedToClassProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'sharedToClass');
    });
  }

  QueryBuilder<JournalEntryCollection, String, QQueryOperations>
      tagsJsonProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'tagsJson');
    });
  }

  QueryBuilder<JournalEntryCollection, String, QQueryOperations>
      titleProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'title');
    });
  }

  QueryBuilder<JournalEntryCollection, int, QQueryOperations>
      updatedAtEpochProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'updatedAtEpoch');
    });
  }

  QueryBuilder<JournalEntryCollection, int, QQueryOperations>
      versionProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'version');
    });
  }

  QueryBuilder<JournalEntryCollection, String, QQueryOperations>
      weatherProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'weather');
    });
  }
}