// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'point_record.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 GetPointRecordCollection on Isar {
  IsarCollection<PointRecord> get pointRecords => this.collection();
}

const PointRecordSchema = CollectionSchema(
  name: r'PointRecord',
  id: 733086018020266618,
  properties: {
    r'arrowsPerEnd': PropertySchema(
      id: 0,
      name: r'arrowsPerEnd',
      type: IsarType.long,
    ),
    r'averageScore': PropertySchema(
      id: 1,
      name: r'averageScore',
      type: IsarType.double,
    ),
    r'bowType': PropertySchema(
      id: 2,
      name: r'bowType',
      type: IsarType.byte,
      enumMap: _PointRecordbowTypeEnumValueMap,
    ),
    r'completedAt': PropertySchema(
      id: 3,
      name: r'completedAt',
      type: IsarType.dateTime,
    ),
    r'createdAt': PropertySchema(
      id: 4,
      name: r'createdAt',
      type: IsarType.dateTime,
    ),
    r'distanceMeters': PropertySchema(
      id: 5,
      name: r'distanceMeters',
      type: IsarType.long,
    ),
    r'endCount': PropertySchema(
      id: 6,
      name: r'endCount',
      type: IsarType.long,
    ),
    r'hitPoints': PropertySchema(
      id: 7,
      name: r'hitPoints',
      type: IsarType.objectList,
      target: r'HitPoint',
    ),
    r'isDraft': PropertySchema(
      id: 8,
      name: r'isDraft',
      type: IsarType.bool,
    ),
    r'note': PropertySchema(
      id: 9,
      name: r'note',
      type: IsarType.string,
    ),
    r'scores': PropertySchema(
      id: 10,
      name: r'scores',
      type: IsarType.longList,
    ),
    r'status': PropertySchema(
      id: 11,
      name: r'status',
      type: IsarType.byte,
      enumMap: _PointRecordstatusEnumValueMap,
    ),
    r'targetFaceType': PropertySchema(
      id: 12,
      name: r'targetFaceType',
      type: IsarType.byte,
      enumMap: _PointRecordtargetFaceTypeEnumValueMap,
    ),
    r'title': PropertySchema(
      id: 13,
      name: r'title',
      type: IsarType.string,
    ),
    r'totalArrows': PropertySchema(
      id: 14,
      name: r'totalArrows',
      type: IsarType.long,
    ),
    r'totalScore': PropertySchema(
      id: 15,
      name: r'totalScore',
      type: IsarType.long,
    ),
    r'updatedAt': PropertySchema(
      id: 16,
      name: r'updatedAt',
      type: IsarType.dateTime,
    )
  },
  estimateSize: _pointRecordEstimateSize,
  serialize: _pointRecordSerialize,
  deserialize: _pointRecordDeserialize,
  deserializeProp: _pointRecordDeserializeProp,
  idName: r'id',
  indexes: {
    r'updatedAt': IndexSchema(
      id: -6238191080293565125,
      name: r'updatedAt',
      unique: false,
      replace: false,
      properties: [
        IndexPropertySchema(
          name: r'updatedAt',
          type: IndexType.value,
          caseSensitive: false,
        )
      ],
    ),
    r'createdAt': IndexSchema(
      id: -3433535483987302584,
      name: r'createdAt',
      unique: false,
      replace: false,
      properties: [
        IndexPropertySchema(
          name: r'createdAt',
          type: IndexType.value,
          caseSensitive: false,
        )
      ],
    ),
    r'completedAt': IndexSchema(
      id: -3156591011457686752,
      name: r'completedAt',
      unique: false,
      replace: false,
      properties: [
        IndexPropertySchema(
          name: r'completedAt',
          type: IndexType.value,
          caseSensitive: false,
        )
      ],
    )
  },
  links: {},
  embeddedSchemas: {r'HitPoint': HitPointSchema},
  getId: _pointRecordGetId,
  getLinks: _pointRecordGetLinks,
  attach: _pointRecordAttach,
  version: '3.1.0+1',
);

int _pointRecordEstimateSize(
  PointRecord object,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  var bytesCount = offsets.last;
  bytesCount += 3 + object.hitPoints.length * 3;
  {
    final offsets = allOffsets[HitPoint]!;
    for (var i = 0; i < object.hitPoints.length; i++) {
      final value = object.hitPoints[i];
      bytesCount += HitPointSchema.estimateSize(value, offsets, allOffsets);
    }
  }
  {
    final value = object.note;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  bytesCount += 3 + object.scores.length * 8;
  bytesCount += 3 + object.title.length * 3;
  return bytesCount;
}

void _pointRecordSerialize(
  PointRecord object,
  IsarWriter writer,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  writer.writeLong(offsets[0], object.arrowsPerEnd);
  writer.writeDouble(offsets[1], object.averageScore);
  writer.writeByte(offsets[2], object.bowType.index);
  writer.writeDateTime(offsets[3], object.completedAt);
  writer.writeDateTime(offsets[4], object.createdAt);
  writer.writeLong(offsets[5], object.distanceMeters);
  writer.writeLong(offsets[6], object.endCount);
  writer.writeObjectList<HitPoint>(
    offsets[7],
    allOffsets,
    HitPointSchema.serialize,
    object.hitPoints,
  );
  writer.writeBool(offsets[8], object.isDraft);
  writer.writeString(offsets[9], object.note);
  writer.writeLongList(offsets[10], object.scores);
  writer.writeByte(offsets[11], object.status.index);
  writer.writeByte(offsets[12], object.targetFaceType.index);
  writer.writeString(offsets[13], object.title);
  writer.writeLong(offsets[14], object.totalArrows);
  writer.writeLong(offsets[15], object.totalScore);
  writer.writeDateTime(offsets[16], object.updatedAt);
}

PointRecord _pointRecordDeserialize(
  Id id,
  IsarReader reader,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  final object = PointRecord();
  object.arrowsPerEnd = reader.readLong(offsets[0]);
  object.bowType =
      _PointRecordbowTypeValueEnumMap[reader.readByteOrNull(offsets[2])] ??
          BowType.recurve;
  object.completedAt = reader.readDateTimeOrNull(offsets[3]);
  object.createdAt = reader.readDateTime(offsets[4]);
  object.distanceMeters = reader.readLong(offsets[5]);
  object.endCount = reader.readLong(offsets[6]);
  object.hitPoints = reader.readObjectList<HitPoint>(
        offsets[7],
        HitPointSchema.deserialize,
        allOffsets,
        HitPoint(),
      ) ??
      [];
  object.id = id;
  object.note = reader.readStringOrNull(offsets[9]);
  object.scores = reader.readLongList(offsets[10]) ?? [];
  object.status =
      _PointRecordstatusValueEnumMap[reader.readByteOrNull(offsets[11])] ??
          PointRecordStatus.draft;
  object.targetFaceType = _PointRecordtargetFaceTypeValueEnumMap[
          reader.readByteOrNull(offsets[12])] ??
      TargetFaceType.cm40;
  object.title = reader.readString(offsets[13]);
  object.updatedAt = reader.readDateTime(offsets[16]);
  return object;
}

P _pointRecordDeserializeProp<P>(
  IsarReader reader,
  int propertyId,
  int offset,
  Map<Type, List<int>> allOffsets,
) {
  switch (propertyId) {
    case 0:
      return (reader.readLong(offset)) as P;
    case 1:
      return (reader.readDoubleOrNull(offset)) as P;
    case 2:
      return (_PointRecordbowTypeValueEnumMap[reader.readByteOrNull(offset)] ??
          BowType.recurve) as P;
    case 3:
      return (reader.readDateTimeOrNull(offset)) as P;
    case 4:
      return (reader.readDateTime(offset)) as P;
    case 5:
      return (reader.readLong(offset)) as P;
    case 6:
      return (reader.readLong(offset)) as P;
    case 7:
      return (reader.readObjectList<HitPoint>(
            offset,
            HitPointSchema.deserialize,
            allOffsets,
            HitPoint(),
          ) ??
          []) as P;
    case 8:
      return (reader.readBool(offset)) as P;
    case 9:
      return (reader.readStringOrNull(offset)) as P;
    case 10:
      return (reader.readLongList(offset) ?? []) as P;
    case 11:
      return (_PointRecordstatusValueEnumMap[reader.readByteOrNull(offset)] ??
          PointRecordStatus.draft) as P;
    case 12:
      return (_PointRecordtargetFaceTypeValueEnumMap[
              reader.readByteOrNull(offset)] ??
          TargetFaceType.cm40) as P;
    case 13:
      return (reader.readString(offset)) as P;
    case 14:
      return (reader.readLong(offset)) as P;
    case 15:
      return (reader.readLong(offset)) as P;
    case 16:
      return (reader.readDateTime(offset)) as P;
    default:
      throw IsarError('Unknown property with id $propertyId');
  }
}

const _PointRecordbowTypeEnumValueMap = {
  'recurve': 0,
  'compound': 1,
  'barebow': 2,
  'traditional': 3,
  'longbow': 4,
  'other': 5,
};
const _PointRecordbowTypeValueEnumMap = {
  0: BowType.recurve,
  1: BowType.compound,
  2: BowType.barebow,
  3: BowType.traditional,
  4: BowType.longbow,
  5: BowType.other,
};
const _PointRecordstatusEnumValueMap = {
  'draft': 0,
  'completed': 1,
};
const _PointRecordstatusValueEnumMap = {
  0: PointRecordStatus.draft,
  1: PointRecordStatus.completed,
};
const _PointRecordtargetFaceTypeEnumValueMap = {
  'cm40': 0,
  'cm60': 1,
  'cm80': 2,
  'cm122': 3,
  'vegas3Spot': 4,
  'vertical3Spot': 5,
  'custom': 6,
};
const _PointRecordtargetFaceTypeValueEnumMap = {
  0: TargetFaceType.cm40,
  1: TargetFaceType.cm60,
  2: TargetFaceType.cm80,
  3: TargetFaceType.cm122,
  4: TargetFaceType.vegas3Spot,
  5: TargetFaceType.vertical3Spot,
  6: TargetFaceType.custom,
};

Id _pointRecordGetId(PointRecord object) {
  return object.id;
}

List<IsarLinkBase<dynamic>> _pointRecordGetLinks(PointRecord object) {
  return [];
}

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterWhere> anyUpdatedAt() {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(
        const IndexWhereClause.any(indexName: r'updatedAt'),
      );
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterWhere> anyCreatedAt() {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(
        const IndexWhereClause.any(indexName: r'createdAt'),
      );
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterWhere> anyCompletedAt() {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(
        const IndexWhereClause.any(indexName: r'completedAt'),
      );
    });
  }
}

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

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

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

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> updatedAtEqualTo(
      DateTime updatedAt) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.equalTo(
        indexName: r'updatedAt',
        value: [updatedAt],
      ));
    });
  }

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

  QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
      updatedAtGreaterThan(
    DateTime updatedAt, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'updatedAt',
        lower: [updatedAt],
        includeLower: include,
        upper: [],
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> updatedAtLessThan(
    DateTime updatedAt, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'updatedAt',
        lower: [],
        upper: [updatedAt],
        includeUpper: include,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> updatedAtBetween(
    DateTime lowerUpdatedAt,
    DateTime upperUpdatedAt, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'updatedAt',
        lower: [lowerUpdatedAt],
        includeLower: includeLower,
        upper: [upperUpdatedAt],
        includeUpper: includeUpper,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> createdAtEqualTo(
      DateTime createdAt) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.equalTo(
        indexName: r'createdAt',
        value: [createdAt],
      ));
    });
  }

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

  QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
      createdAtGreaterThan(
    DateTime createdAt, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'createdAt',
        lower: [createdAt],
        includeLower: include,
        upper: [],
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> createdAtLessThan(
    DateTime createdAt, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'createdAt',
        lower: [],
        upper: [createdAt],
        includeUpper: include,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> createdAtBetween(
    DateTime lowerCreatedAt,
    DateTime upperCreatedAt, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'createdAt',
        lower: [lowerCreatedAt],
        includeLower: includeLower,
        upper: [upperCreatedAt],
        includeUpper: includeUpper,
      ));
    });
  }

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> completedAtEqualTo(
      DateTime? completedAt) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.equalTo(
        indexName: r'completedAt',
        value: [completedAt],
      ));
    });
  }

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

  QueryBuilder<PointRecord, PointRecord, QAfterWhereClause>
      completedAtGreaterThan(
    DateTime? completedAt, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'completedAt',
        lower: [completedAt],
        includeLower: include,
        upper: [],
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> completedAtLessThan(
    DateTime? completedAt, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'completedAt',
        lower: [],
        upper: [completedAt],
        includeUpper: include,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterWhereClause> completedAtBetween(
    DateTime? lowerCompletedAt,
    DateTime? upperCompletedAt, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addWhereClause(IndexWhereClause.between(
        indexName: r'completedAt',
        lower: [lowerCompletedAt],
        includeLower: includeLower,
        upper: [upperCompletedAt],
        includeUpper: includeUpper,
      ));
    });
  }
}

extension PointRecordQueryFilter
    on QueryBuilder<PointRecord, PointRecord, QFilterCondition> {
  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      arrowsPerEndEqualTo(int value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'arrowsPerEnd',
        value: value,
      ));
    });
  }

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

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      averageScoreIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'averageScore',
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      averageScoreIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'averageScore',
      ));
    });
  }

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

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      averageScoreBetween(
    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'averageScore',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        epsilon: epsilon,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> bowTypeEqualTo(
      BowType value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'bowType',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      bowTypeGreaterThan(
    BowType value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'bowType',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> bowTypeLessThan(
    BowType value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'bowType',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> bowTypeBetween(
    BowType lower,
    BowType upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'bowType',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      completedAtIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'completedAt',
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      completedAtIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'completedAt',
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      completedAtEqualTo(DateTime? value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'completedAt',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      completedAtGreaterThan(
    DateTime? value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'completedAt',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      completedAtLessThan(
    DateTime? value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'completedAt',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      completedAtBetween(
    DateTime? lower,
    DateTime? upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'completedAt',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      createdAtEqualTo(DateTime value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'createdAt',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      createdAtGreaterThan(
    DateTime value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'createdAt',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      createdAtLessThan(
    DateTime value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'createdAt',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      createdAtBetween(
    DateTime lower,
    DateTime upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'createdAt',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
      ));
    });
  }

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

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

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

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

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

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

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      hitPointsLengthEqualTo(int length) {
    return QueryBuilder.apply(this, (query) {
      return query.listLength(
        r'hitPoints',
        length,
        true,
        length,
        true,
      );
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      hitPointsIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.listLength(
        r'hitPoints',
        0,
        true,
        0,
        true,
      );
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      hitPointsIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.listLength(
        r'hitPoints',
        0,
        false,
        999999,
        true,
      );
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      hitPointsLengthLessThan(
    int length, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.listLength(
        r'hitPoints',
        0,
        true,
        length,
        include,
      );
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      hitPointsLengthGreaterThan(
    int length, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.listLength(
        r'hitPoints',
        length,
        include,
        999999,
        true,
      );
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      hitPointsLengthBetween(
    int lower,
    int upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.listLength(
        r'hitPoints',
        lower,
        includeLower,
        upper,
        includeUpper,
      );
    });
  }

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

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

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

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> noteIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'note',
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      noteIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'note',
      ));
    });
  }

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

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> noteBetween(
    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'note',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> noteIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'note',
        value: '',
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      noteIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'note',
        value: '',
      ));
    });
  }

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

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

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      scoresLengthEqualTo(int length) {
    return QueryBuilder.apply(this, (query) {
      return query.listLength(
        r'scores',
        length,
        true,
        length,
        true,
      );
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      scoresIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.listLength(
        r'scores',
        0,
        true,
        0,
        true,
      );
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      scoresIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.listLength(
        r'scores',
        0,
        false,
        999999,
        true,
      );
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      scoresLengthLessThan(
    int length, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.listLength(
        r'scores',
        0,
        true,
        length,
        include,
      );
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      scoresLengthGreaterThan(
    int length, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.listLength(
        r'scores',
        length,
        include,
        999999,
        true,
      );
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      scoresLengthBetween(
    int lower,
    int upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.listLength(
        r'scores',
        lower,
        includeLower,
        upper,
        includeUpper,
      );
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> statusEqualTo(
      PointRecordStatus value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'status',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      statusGreaterThan(
    PointRecordStatus value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'status',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> statusLessThan(
    PointRecordStatus value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'status',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition> statusBetween(
    PointRecordStatus lower,
    PointRecordStatus upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'status',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      targetFaceTypeEqualTo(TargetFaceType value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'targetFaceType',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      targetFaceTypeGreaterThan(
    TargetFaceType value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'targetFaceType',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      targetFaceTypeLessThan(
    TargetFaceType value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'targetFaceType',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      targetFaceTypeBetween(
    TargetFaceType lower,
    TargetFaceType upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'targetFaceType',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
      ));
    });
  }

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

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

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

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

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

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

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

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

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      updatedAtEqualTo(DateTime value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'updatedAt',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      updatedAtGreaterThan(
    DateTime value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'updatedAt',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      updatedAtLessThan(
    DateTime value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'updatedAt',
        value: value,
      ));
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      updatedAtBetween(
    DateTime lower,
    DateTime upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'updatedAt',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
      ));
    });
  }
}

extension PointRecordQueryObject
    on QueryBuilder<PointRecord, PointRecord, QFilterCondition> {
  QueryBuilder<PointRecord, PointRecord, QAfterFilterCondition>
      hitPointsElement(FilterQuery<HitPoint> q) {
    return QueryBuilder.apply(this, (query) {
      return query.object(q, r'hitPoints');
    });
  }
}

extension PointRecordQueryLinks
    on QueryBuilder<PointRecord, PointRecord, QFilterCondition> {}

extension PointRecordQuerySortBy
    on QueryBuilder<PointRecord, PointRecord, QSortBy> {
  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByArrowsPerEnd() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'arrowsPerEnd', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
      sortByArrowsPerEndDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'arrowsPerEnd', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByAverageScore() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'averageScore', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
      sortByAverageScoreDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'averageScore', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByBowType() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'bowType', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByBowTypeDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'bowType', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByCompletedAt() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'completedAt', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByCompletedAtDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'completedAt', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByCreatedAt() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createdAt', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByCreatedAtDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createdAt', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByDistanceMeters() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'distanceMeters', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
      sortByDistanceMetersDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'distanceMeters', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByEndCount() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'endCount', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByEndCountDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'endCount', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByIsDraft() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isDraft', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByIsDraftDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isDraft', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByNote() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'note', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByNoteDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'note', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByStatus() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'status', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByStatusDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'status', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTargetFaceType() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'targetFaceType', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
      sortByTargetFaceTypeDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'targetFaceType', Sort.desc);
    });
  }

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTotalArrows() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'totalArrows', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTotalArrowsDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'totalArrows', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTotalScore() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'totalScore', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByTotalScoreDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'totalScore', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByUpdatedAt() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updatedAt', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> sortByUpdatedAtDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updatedAt', Sort.desc);
    });
  }
}

extension PointRecordQuerySortThenBy
    on QueryBuilder<PointRecord, PointRecord, QSortThenBy> {
  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByArrowsPerEnd() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'arrowsPerEnd', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
      thenByArrowsPerEndDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'arrowsPerEnd', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByAverageScore() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'averageScore', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
      thenByAverageScoreDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'averageScore', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByBowType() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'bowType', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByBowTypeDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'bowType', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByCompletedAt() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'completedAt', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByCompletedAtDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'completedAt', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByCreatedAt() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createdAt', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByCreatedAtDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'createdAt', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByDistanceMeters() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'distanceMeters', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
      thenByDistanceMetersDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'distanceMeters', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByEndCount() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'endCount', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByEndCountDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'endCount', Sort.desc);
    });
  }

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByIsDraft() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isDraft', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByIsDraftDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'isDraft', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByNote() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'note', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByNoteDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'note', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByStatus() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'status', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByStatusDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'status', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTargetFaceType() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'targetFaceType', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy>
      thenByTargetFaceTypeDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'targetFaceType', Sort.desc);
    });
  }

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

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

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTotalArrows() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'totalArrows', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTotalArrowsDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'totalArrows', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTotalScore() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'totalScore', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByTotalScoreDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'totalScore', Sort.desc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByUpdatedAt() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updatedAt', Sort.asc);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QAfterSortBy> thenByUpdatedAtDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'updatedAt', Sort.desc);
    });
  }
}

extension PointRecordQueryWhereDistinct
    on QueryBuilder<PointRecord, PointRecord, QDistinct> {
  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByArrowsPerEnd() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'arrowsPerEnd');
    });
  }

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByAverageScore() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'averageScore');
    });
  }

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByBowType() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'bowType');
    });
  }

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByCompletedAt() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'completedAt');
    });
  }

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByCreatedAt() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'createdAt');
    });
  }

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByDistanceMeters() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'distanceMeters');
    });
  }

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByEndCount() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'endCount');
    });
  }

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByIsDraft() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'isDraft');
    });
  }

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByNote(
      {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'note', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByScores() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'scores');
    });
  }

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByStatus() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'status');
    });
  }

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByTargetFaceType() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'targetFaceType');
    });
  }

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

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByTotalArrows() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'totalArrows');
    });
  }

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByTotalScore() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'totalScore');
    });
  }

  QueryBuilder<PointRecord, PointRecord, QDistinct> distinctByUpdatedAt() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'updatedAt');
    });
  }
}

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

  QueryBuilder<PointRecord, int, QQueryOperations> arrowsPerEndProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'arrowsPerEnd');
    });
  }

  QueryBuilder<PointRecord, double?, QQueryOperations> averageScoreProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'averageScore');
    });
  }

  QueryBuilder<PointRecord, BowType, QQueryOperations> bowTypeProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'bowType');
    });
  }

  QueryBuilder<PointRecord, DateTime?, QQueryOperations> completedAtProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'completedAt');
    });
  }

  QueryBuilder<PointRecord, DateTime, QQueryOperations> createdAtProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'createdAt');
    });
  }

  QueryBuilder<PointRecord, int, QQueryOperations> distanceMetersProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'distanceMeters');
    });
  }

  QueryBuilder<PointRecord, int, QQueryOperations> endCountProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'endCount');
    });
  }

  QueryBuilder<PointRecord, List<HitPoint>, QQueryOperations>
      hitPointsProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'hitPoints');
    });
  }

  QueryBuilder<PointRecord, bool, QQueryOperations> isDraftProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'isDraft');
    });
  }

  QueryBuilder<PointRecord, String?, QQueryOperations> noteProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'note');
    });
  }

  QueryBuilder<PointRecord, List<int>, QQueryOperations> scoresProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'scores');
    });
  }

  QueryBuilder<PointRecord, PointRecordStatus, QQueryOperations>
      statusProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'status');
    });
  }

  QueryBuilder<PointRecord, TargetFaceType, QQueryOperations>
      targetFaceTypeProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'targetFaceType');
    });
  }

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

  QueryBuilder<PointRecord, int, QQueryOperations> totalArrowsProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'totalArrows');
    });
  }

  QueryBuilder<PointRecord, int, QQueryOperations> totalScoreProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'totalScore');
    });
  }

  QueryBuilder<PointRecord, DateTime, QQueryOperations> updatedAtProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'updatedAt');
    });
  }
}

// **************************************************************************
// IsarEmbeddedGenerator
// **************************************************************************

// 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

const HitPointSchema = Schema(
  name: r'HitPoint',
  id: -4202326135308389480,
  properties: {
    r'arrowIndex': PropertySchema(
      id: 0,
      name: r'arrowIndex',
      type: IsarType.long,
    ),
    r'endIndex': PropertySchema(
      id: 1,
      name: r'endIndex',
      type: IsarType.long,
    ),
    r'isMiss': PropertySchema(
      id: 2,
      name: r'isMiss',
      type: IsarType.bool,
    ),
    r'normalizedX': PropertySchema(
      id: 3,
      name: r'normalizedX',
      type: IsarType.double,
    ),
    r'normalizedY': PropertySchema(
      id: 4,
      name: r'normalizedY',
      type: IsarType.double,
    ),
    r'score': PropertySchema(
      id: 5,
      name: r'score',
      type: IsarType.long,
    )
  },
  estimateSize: _hitPointEstimateSize,
  serialize: _hitPointSerialize,
  deserialize: _hitPointDeserialize,
  deserializeProp: _hitPointDeserializeProp,
);

int _hitPointEstimateSize(
  HitPoint object,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  var bytesCount = offsets.last;
  return bytesCount;
}

void _hitPointSerialize(
  HitPoint object,
  IsarWriter writer,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  writer.writeLong(offsets[0], object.arrowIndex);
  writer.writeLong(offsets[1], object.endIndex);
  writer.writeBool(offsets[2], object.isMiss);
  writer.writeDouble(offsets[3], object.normalizedX);
  writer.writeDouble(offsets[4], object.normalizedY);
  writer.writeLong(offsets[5], object.score);
}

HitPoint _hitPointDeserialize(
  Id id,
  IsarReader reader,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  final object = HitPoint(
    arrowIndex: reader.readLongOrNull(offsets[0]) ?? 0,
    endIndex: reader.readLongOrNull(offsets[1]) ?? 0,
    isMiss: reader.readBoolOrNull(offsets[2]) ?? false,
    normalizedX: reader.readDoubleOrNull(offsets[3]) ?? 0,
    normalizedY: reader.readDoubleOrNull(offsets[4]) ?? 0,
    score: reader.readLongOrNull(offsets[5]),
  );
  return object;
}

P _hitPointDeserializeProp<P>(
  IsarReader reader,
  int propertyId,
  int offset,
  Map<Type, List<int>> allOffsets,
) {
  switch (propertyId) {
    case 0:
      return (reader.readLongOrNull(offset) ?? 0) as P;
    case 1:
      return (reader.readLongOrNull(offset) ?? 0) as P;
    case 2:
      return (reader.readBoolOrNull(offset) ?? false) as P;
    case 3:
      return (reader.readDoubleOrNull(offset) ?? 0) as P;
    case 4:
      return (reader.readDoubleOrNull(offset) ?? 0) as P;
    case 5:
      return (reader.readLongOrNull(offset)) as P;
    default:
      throw IsarError('Unknown property with id $propertyId');
  }
}

extension HitPointQueryFilter
    on QueryBuilder<HitPoint, HitPoint, QFilterCondition> {
  QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> arrowIndexEqualTo(
      int value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'arrowIndex',
        value: value,
      ));
    });
  }

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

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

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

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

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

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

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

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

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

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

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

  QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> normalizedXBetween(
    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'normalizedX',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        epsilon: epsilon,
      ));
    });
  }

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

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

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

  QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> normalizedYBetween(
    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'normalizedY',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        epsilon: epsilon,
      ));
    });
  }

  QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> scoreIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'score',
      ));
    });
  }

  QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> scoreIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'score',
      ));
    });
  }

  QueryBuilder<HitPoint, HitPoint, QAfterFilterCondition> scoreEqualTo(
      int? value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'score',
        value: value,
      ));
    });
  }

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

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

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

extension HitPointQueryObject
    on QueryBuilder<HitPoint, HitPoint, QFilterCondition> {}