nj/app/lib/data/local/collections/journal_element_collection.g.dart

// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'journal_element_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 GetJournalElementCollectionCollection on Isar {
  IsarCollection<JournalElementCollection> get journalElementCollections =>
      this.collection();
}

const JournalElementCollectionSchema = CollectionSchema(
  name: r'JournalElementCollection',
  id: -3625932583395690305,
  properties: {
    r'contentJson': PropertySchema(
      id: 0,
      name: r'contentJson',
      type: IsarType.string,
    ),
    r'createdAtEpoch': PropertySchema(
      id: 1,
      name: r'createdAtEpoch',
      type: IsarType.long,
    ),
    r'elementType': PropertySchema(
      id: 2,
      name: r'elementType',
      type: IsarType.string,
    ),
    r'height': PropertySchema(
      id: 3,
      name: r'height',
      type: IsarType.double,
    ),
    r'id': PropertySchema(
      id: 4,
      name: r'id',
      type: IsarType.string,
    ),
    r'isDeleted': PropertySchema(
      id: 5,
      name: r'isDeleted',
      type: IsarType.bool,
    ),
    r'journalId': PropertySchema(
      id: 6,
      name: r'journalId',
      type: IsarType.string,
    ),
    r'positionX': PropertySchema(
      id: 7,
      name: r'positionX',
      type: IsarType.double,
    ),
    r'positionY': PropertySchema(
      id: 8,
      name: r'positionY',
      type: IsarType.double,
    ),
    r'rotation': PropertySchema(
      id: 9,
      name: r'rotation',
      type: IsarType.double,
    ),
    r'updatedAtEpoch': PropertySchema(
      id: 10,
      name: r'updatedAtEpoch',
      type: IsarType.long,
    ),
    r'version': PropertySchema(
      id: 11,
      name: r'version',
      type: IsarType.long,
    ),
    r'width': PropertySchema(
      id: 12,
      name: r'width',
      type: IsarType.double,
    ),
    r'zIndex': PropertySchema(
      id: 13,
      name: r'zIndex',
      type: IsarType.long,
    )
  },
  estimateSize: _journalElementCollectionEstimateSize,
  serialize: _journalElementCollectionSerialize,
  deserialize: _journalElementCollectionDeserialize,
  deserializeProp: _journalElementCollectionDeserializeProp,
  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'journalId': IndexSchema(
      id: 1745640946427815323,
      name: r'journalId',
      unique: false,
      replace: false,
      properties: [
        IndexPropertySchema(
          name: r'journalId',
          type: IndexType.hash,
          caseSensitive: true,
        )
      ],
    )
  },
  links: {},
  embeddedSchemas: {},
  getId: _journalElementCollectionGetId,
  getLinks: _journalElementCollectionGetLinks,
  attach: _journalElementCollectionAttach,
  version: '3.1.0+1',
);

int _journalElementCollectionEstimateSize(
  JournalElementCollection object,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  var bytesCount = offsets.last;
  bytesCount += 3 + object.contentJson.length * 3;
  bytesCount += 3 + object.elementType.length * 3;
  bytesCount += 3 + object.id.length * 3;
  bytesCount += 3 + object.journalId.length * 3;
  return bytesCount;
}

void _journalElementCollectionSerialize(
  JournalElementCollection object,
  IsarWriter writer,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  writer.writeString(offsets[0], object.contentJson);
  writer.writeLong(offsets[1], object.createdAtEpoch);
  writer.writeString(offsets[2], object.elementType);
  writer.writeDouble(offsets[3], object.height);
  writer.writeString(offsets[4], object.id);
  writer.writeBool(offsets[5], object.isDeleted);
  writer.writeString(offsets[6], object.journalId);
  writer.writeDouble(offsets[7], object.positionX);
  writer.writeDouble(offsets[8], object.positionY);
  writer.writeDouble(offsets[9], object.rotation);
  writer.writeLong(offsets[10], object.updatedAtEpoch);
  writer.writeLong(offsets[11], object.version);
  writer.writeDouble(offsets[12], object.width);
  writer.writeLong(offsets[13], object.zIndex);
}

JournalElementCollection _journalElementCollectionDeserialize(
  Id id,
  IsarReader reader,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  final object = JournalElementCollection();
  object.contentJson = reader.readString(offsets[0]);
  object.createdAtEpoch = reader.readLong(offsets[1]);
  object.elementType = reader.readString(offsets[2]);
  object.height = reader.readDouble(offsets[3]);
  object.id = reader.readString(offsets[4]);
  object.isDeleted = reader.readBool(offsets[5]);
  object.isarId = id;
  object.journalId = reader.readString(offsets[6]);
  object.positionX = reader.readDouble(offsets[7]);
  object.positionY = reader.readDouble(offsets[8]);
  object.rotation = reader.readDouble(offsets[9]);
  object.updatedAtEpoch = reader.readLong(offsets[10]);
  object.version = reader.readLong(offsets[11]);
  object.width = reader.readDouble(offsets[12]);
  object.zIndex = reader.readLong(offsets[13]);
  return object;
}

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

Id _journalElementCollectionGetId(JournalElementCollection object) {
  return object.isarId;
}

List<IsarLinkBase<dynamic>> _journalElementCollectionGetLinks(
    JournalElementCollection object) {
  return [];
}

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

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      QAfterWhereClause> isarIdGreaterThan(Id isarId, {bool include = false}) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(
        IdWhereClause.greaterThan(lower: isarId, includeLower: include),
      );
    });
  }

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      QAfterWhereClause> idEqualTo(String id) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.equalTo(
        indexName: r'id',
        value: [id],
      ));
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      QAfterWhereClause> journalIdEqualTo(String journalId) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.equalTo(
        indexName: r'journalId',
        value: [journalId],
      ));
    });
  }

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

extension JournalElementCollectionQueryFilter on QueryBuilder<
    JournalElementCollection, JournalElementCollection, QFilterCondition> {
  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> contentJsonEqualTo(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'contentJson',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> contentJsonBetween(
    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'contentJson',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> contentJsonIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'contentJson',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> contentJsonIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'contentJson',
        value: '',
      ));
    });
  }

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> elementTypeEqualTo(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'elementType',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> elementTypeBetween(
    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'elementType',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> elementTypeIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'elementType',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> elementTypeIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'elementType',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> heightEqualTo(
    double value, {
    double epsilon = Query.epsilon,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'height',
        value: value,
        epsilon: epsilon,
      ));
    });
  }

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> heightBetween(
    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'height',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        epsilon: epsilon,
      ));
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
          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<JournalElementCollection, JournalElementCollection,
          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<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> idIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'id',
        value: '',
      ));
    });
  }

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

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> journalIdEqualTo(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'journalId',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> journalIdBetween(
    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'journalId',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> journalIdIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'journalId',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> journalIdIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'journalId',
        value: '',
      ));
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> positionXEqualTo(
    double value, {
    double epsilon = Query.epsilon,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'positionX',
        value: value,
        epsilon: epsilon,
      ));
    });
  }

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> positionXBetween(
    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'positionX',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        epsilon: epsilon,
      ));
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> positionYEqualTo(
    double value, {
    double epsilon = Query.epsilon,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'positionY',
        value: value,
        epsilon: epsilon,
      ));
    });
  }

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> positionYBetween(
    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'positionY',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        epsilon: epsilon,
      ));
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> rotationEqualTo(
    double value, {
    double epsilon = Query.epsilon,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'rotation',
        value: value,
        epsilon: epsilon,
      ));
    });
  }

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> rotationBetween(
    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'rotation',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        epsilon: epsilon,
      ));
    });
  }

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> versionEqualTo(int value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'version',
        value: value,
      ));
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      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<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> widthEqualTo(
    double value, {
    double epsilon = Query.epsilon,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'width',
        value: value,
        epsilon: epsilon,
      ));
    });
  }

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection,
      QAfterFilterCondition> widthBetween(
    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'width',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        epsilon: epsilon,
      ));
    });
  }

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

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

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

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

extension JournalElementCollectionQueryObject on QueryBuilder<
    JournalElementCollection, JournalElementCollection, QFilterCondition> {}

extension JournalElementCollectionQueryLinks on QueryBuilder<
    JournalElementCollection, JournalElementCollection, QFilterCondition> {}

extension JournalElementCollectionQuerySortBy on QueryBuilder<
    JournalElementCollection, JournalElementCollection, QSortBy> {
  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByContentJson() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'contentJson', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByContentJsonDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'contentJson', Sort.desc);
    });
  }

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByElementType() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'elementType', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByElementTypeDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'elementType', Sort.desc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByHeight() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'height', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByHeightDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'height', Sort.desc);
    });
  }

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

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

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByJournalId() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'journalId', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByJournalIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'journalId', Sort.desc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByPositionX() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'positionX', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByPositionXDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'positionX', Sort.desc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByPositionY() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'positionY', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByPositionYDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'positionY', Sort.desc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByRotation() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'rotation', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByRotationDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'rotation', Sort.desc);
    });
  }

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

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

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByWidth() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'width', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByWidthDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'width', Sort.desc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByZIndex() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'zIndex', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      sortByZIndexDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'zIndex', Sort.desc);
    });
  }
}

extension JournalElementCollectionQuerySortThenBy on QueryBuilder<
    JournalElementCollection, JournalElementCollection, QSortThenBy> {
  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByContentJson() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'contentJson', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByContentJsonDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'contentJson', Sort.desc);
    });
  }

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByElementType() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'elementType', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByElementTypeDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'elementType', Sort.desc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByHeight() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'height', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByHeightDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'height', Sort.desc);
    });
  }

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

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

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

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

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByJournalId() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'journalId', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByJournalIdDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'journalId', Sort.desc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByPositionX() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'positionX', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByPositionXDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'positionX', Sort.desc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByPositionY() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'positionY', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByPositionYDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'positionY', Sort.desc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByRotation() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'rotation', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByRotationDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'rotation', Sort.desc);
    });
  }

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

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

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByWidth() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'width', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByWidthDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'width', Sort.desc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByZIndex() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'zIndex', Sort.asc);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QAfterSortBy>
      thenByZIndexDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'zIndex', Sort.desc);
    });
  }
}

extension JournalElementCollectionQueryWhereDistinct on QueryBuilder<
    JournalElementCollection, JournalElementCollection, QDistinct> {
  QueryBuilder<JournalElementCollection, JournalElementCollection, QDistinct>
      distinctByContentJson({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'contentJson', caseSensitive: caseSensitive);
    });
  }

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

  QueryBuilder<JournalElementCollection, JournalElementCollection, QDistinct>
      distinctByElementType({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'elementType', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QDistinct>
      distinctByHeight() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'height');
    });
  }

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection, QDistinct>
      distinctByJournalId({bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'journalId', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QDistinct>
      distinctByPositionX() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'positionX');
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QDistinct>
      distinctByPositionY() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'positionY');
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QDistinct>
      distinctByRotation() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'rotation');
    });
  }

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

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

  QueryBuilder<JournalElementCollection, JournalElementCollection, QDistinct>
      distinctByWidth() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'width');
    });
  }

  QueryBuilder<JournalElementCollection, JournalElementCollection, QDistinct>
      distinctByZIndex() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'zIndex');
    });
  }
}

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

  QueryBuilder<JournalElementCollection, String, QQueryOperations>
      contentJsonProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'contentJson');
    });
  }

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

  QueryBuilder<JournalElementCollection, String, QQueryOperations>
      elementTypeProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'elementType');
    });
  }

  QueryBuilder<JournalElementCollection, double, QQueryOperations>
      heightProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'height');
    });
  }

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

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

  QueryBuilder<JournalElementCollection, String, QQueryOperations>
      journalIdProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'journalId');
    });
  }

  QueryBuilder<JournalElementCollection, double, QQueryOperations>
      positionXProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'positionX');
    });
  }

  QueryBuilder<JournalElementCollection, double, QQueryOperations>
      positionYProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'positionY');
    });
  }

  QueryBuilder<JournalElementCollection, double, QQueryOperations>
      rotationProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'rotation');
    });
  }

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

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

  QueryBuilder<JournalElementCollection, double, QQueryOperations>
      widthProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'width');
    });
  }

  QueryBuilder<JournalElementCollection, int, QQueryOperations>
      zIndexProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'zIndex');
    });
  }
}