// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'zip_message.dart';

// **************************************************************************
// 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 ZipReqZipSchema = Schema(
  name: r'ZipReqZip',
  id: 2176882141139579108,
  properties: {
    r'id': PropertySchema(
      id: 0,
      name: r'id',
      type: IsarType.long,
    ),
    r'zip': PropertySchema(
      id: 1,
      name: r'zip',
      type: IsarType.string,
    )
  },
  estimateSize: _zipReqZipEstimateSize,
  serialize: _zipReqZipSerialize,
  deserialize: _zipReqZipDeserialize,
  deserializeProp: _zipReqZipDeserializeProp,
);

int _zipReqZipEstimateSize(
  ZipReqZip object,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  var bytesCount = offsets.last;
  bytesCount += 3 + object.zip.length * 3;
  return bytesCount;
}

void _zipReqZipSerialize(
  ZipReqZip object,
  IsarWriter writer,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  writer.writeLong(offsets[0], object.id);
  writer.writeString(offsets[1], object.zip);
}

ZipReqZip _zipReqZipDeserialize(
  Id id,
  IsarReader reader,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  final object = ZipReqZip();
  object.id = reader.readLong(offsets[0]);
  object.zip = reader.readString(offsets[1]);
  return object;
}

P _zipReqZipDeserializeProp<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.readString(offset)) as P;
    default:
      throw IsarError('Unknown property with id $propertyId');
  }
}

extension ZipReqZipQueryFilter
    on QueryBuilder<ZipReqZip, ZipReqZip, QFilterCondition> {
  QueryBuilder<ZipReqZip, ZipReqZip, QAfterFilterCondition> idEqualTo(
      int value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'id',
        value: value,
      ));
    });
  }

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

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

  QueryBuilder<ZipReqZip, ZipReqZip, QAfterFilterCondition> idBetween(
    int lower,
    int 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<ZipReqZip, ZipReqZip, QAfterFilterCondition> zipEqualTo(
    String value, {
    bool caseSensitive = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'zip',
        value: value,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

  QueryBuilder<ZipReqZip, ZipReqZip, QAfterFilterCondition> zipBetween(
    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'zip',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<ZipReqZip, ZipReqZip, QAfterFilterCondition> zipIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'zip',
        value: '',
      ));
    });
  }

  QueryBuilder<ZipReqZip, ZipReqZip, QAfterFilterCondition> zipIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'zip',
        value: '',
      ));
    });
  }
}

extension ZipReqZipQueryObject
    on QueryBuilder<ZipReqZip, ZipReqZip, QFilterCondition> {}

// 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 ZipSetPosSchema = Schema(
  name: r'ZipSetPos',
  id: 2736271830323112702,
  properties: {
    r'track': PropertySchema(
      id: 0,
      name: r'track',
      type: IsarType.object,
      target: r'ZipTrack',
    ),
    r'zip': PropertySchema(
      id: 1,
      name: r'zip',
      type: IsarType.string,
    )
  },
  estimateSize: _zipSetPosEstimateSize,
  serialize: _zipSetPosSerialize,
  deserialize: _zipSetPosDeserialize,
  deserializeProp: _zipSetPosDeserializeProp,
);

int _zipSetPosEstimateSize(
  ZipSetPos object,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  var bytesCount = offsets.last;
  {
    final value = object.track;
    if (value != null) {
      bytesCount += 3 +
          ZipTrackSchema.estimateSize(value, allOffsets[ZipTrack]!, allOffsets);
    }
  }
  bytesCount += 3 + object.zip.length * 3;
  return bytesCount;
}

void _zipSetPosSerialize(
  ZipSetPos object,
  IsarWriter writer,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  writer.writeObject<ZipTrack>(
    offsets[0],
    allOffsets,
    ZipTrackSchema.serialize,
    object.track,
  );
  writer.writeString(offsets[1], object.zip);
}

ZipSetPos _zipSetPosDeserialize(
  Id id,
  IsarReader reader,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  final object = ZipSetPos();
  object.track = reader.readObjectOrNull<ZipTrack>(
    offsets[0],
    ZipTrackSchema.deserialize,
    allOffsets,
  );
  object.zip = reader.readString(offsets[1]);
  return object;
}

P _zipSetPosDeserializeProp<P>(
  IsarReader reader,
  int propertyId,
  int offset,
  Map<Type, List<int>> allOffsets,
) {
  switch (propertyId) {
    case 0:
      return (reader.readObjectOrNull<ZipTrack>(
        offset,
        ZipTrackSchema.deserialize,
        allOffsets,
      )) as P;
    case 1:
      return (reader.readString(offset)) as P;
    default:
      throw IsarError('Unknown property with id $propertyId');
  }
}

extension ZipSetPosQueryFilter
    on QueryBuilder<ZipSetPos, ZipSetPos, QFilterCondition> {
  QueryBuilder<ZipSetPos, ZipSetPos, QAfterFilterCondition> trackIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'track',
      ));
    });
  }

  QueryBuilder<ZipSetPos, ZipSetPos, QAfterFilterCondition> trackIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'track',
      ));
    });
  }

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

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

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

  QueryBuilder<ZipSetPos, ZipSetPos, QAfterFilterCondition> zipBetween(
    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'zip',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<ZipSetPos, ZipSetPos, QAfterFilterCondition> zipIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'zip',
        value: '',
      ));
    });
  }

  QueryBuilder<ZipSetPos, ZipSetPos, QAfterFilterCondition> zipIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'zip',
        value: '',
      ));
    });
  }
}

extension ZipSetPosQueryObject
    on QueryBuilder<ZipSetPos, ZipSetPos, QFilterCondition> {
  QueryBuilder<ZipSetPos, ZipSetPos, QAfterFilterCondition> track(
      FilterQuery<ZipTrack> q) {
    return QueryBuilder.apply(this, (query) {
      return query.object(q, r'track');
    });
  }
}

// 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 ZipTrackSchema = Schema(
  name: r'ZipTrack',
  id: 8605425681395793610,
  properties: {
    r'pos': PropertySchema(
      id: 0,
      name: r'pos',
      type: IsarType.object,
      target: r'ZipTrackPos',
    ),
    r'time': PropertySchema(
      id: 1,
      name: r'time',
      type: IsarType.string,
    )
  },
  estimateSize: _zipTrackEstimateSize,
  serialize: _zipTrackSerialize,
  deserialize: _zipTrackDeserialize,
  deserializeProp: _zipTrackDeserializeProp,
);

int _zipTrackEstimateSize(
  ZipTrack object,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  var bytesCount = offsets.last;
  {
    final value = object.pos;
    if (value != null) {
      bytesCount += 3 +
          ZipTrackPosSchema.estimateSize(
              value, allOffsets[ZipTrackPos]!, allOffsets);
    }
  }
  bytesCount += 3 + object.time.length * 3;
  return bytesCount;
}

void _zipTrackSerialize(
  ZipTrack object,
  IsarWriter writer,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  writer.writeObject<ZipTrackPos>(
    offsets[0],
    allOffsets,
    ZipTrackPosSchema.serialize,
    object.pos,
  );
  writer.writeString(offsets[1], object.time);
}

ZipTrack _zipTrackDeserialize(
  Id id,
  IsarReader reader,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  final object = ZipTrack();
  object.pos = reader.readObjectOrNull<ZipTrackPos>(
    offsets[0],
    ZipTrackPosSchema.deserialize,
    allOffsets,
  );
  object.time = reader.readString(offsets[1]);
  return object;
}

P _zipTrackDeserializeProp<P>(
  IsarReader reader,
  int propertyId,
  int offset,
  Map<Type, List<int>> allOffsets,
) {
  switch (propertyId) {
    case 0:
      return (reader.readObjectOrNull<ZipTrackPos>(
        offset,
        ZipTrackPosSchema.deserialize,
        allOffsets,
      )) as P;
    case 1:
      return (reader.readString(offset)) as P;
    default:
      throw IsarError('Unknown property with id $propertyId');
  }
}

extension ZipTrackQueryFilter
    on QueryBuilder<ZipTrack, ZipTrack, QFilterCondition> {
  QueryBuilder<ZipTrack, ZipTrack, QAfterFilterCondition> posIsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'pos',
      ));
    });
  }

  QueryBuilder<ZipTrack, ZipTrack, QAfterFilterCondition> posIsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'pos',
      ));
    });
  }

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

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

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

  QueryBuilder<ZipTrack, ZipTrack, QAfterFilterCondition> timeBetween(
    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'time',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<ZipTrack, ZipTrack, QAfterFilterCondition> timeIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'time',
        value: '',
      ));
    });
  }

  QueryBuilder<ZipTrack, ZipTrack, QAfterFilterCondition> timeIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'time',
        value: '',
      ));
    });
  }
}

extension ZipTrackQueryObject
    on QueryBuilder<ZipTrack, ZipTrack, QFilterCondition> {
  QueryBuilder<ZipTrack, ZipTrack, QAfterFilterCondition> pos(
      FilterQuery<ZipTrackPos> q) {
    return QueryBuilder.apply(this, (query) {
      return query.object(q, r'pos');
    });
  }
}

// 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 ZipTrackPosSchema = Schema(
  name: r'ZipTrackPos',
  id: 7837584470752293488,
  properties: {
    r'acc': PropertySchema(
      id: 0,
      name: r'acc',
      type: IsarType.long,
    ),
    r'lat': PropertySchema(
      id: 1,
      name: r'lat',
      type: IsarType.double,
    ),
    r'long': PropertySchema(
      id: 2,
      name: r'long',
      type: IsarType.double,
    )
  },
  estimateSize: _zipTrackPosEstimateSize,
  serialize: _zipTrackPosSerialize,
  deserialize: _zipTrackPosDeserialize,
  deserializeProp: _zipTrackPosDeserializeProp,
);

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

void _zipTrackPosSerialize(
  ZipTrackPos object,
  IsarWriter writer,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  writer.writeLong(offsets[0], object.acc);
  writer.writeDouble(offsets[1], object.lat);
  writer.writeDouble(offsets[2], object.long);
}

ZipTrackPos _zipTrackPosDeserialize(
  Id id,
  IsarReader reader,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  final object = ZipTrackPos();
  object.acc = reader.readLong(offsets[0]);
  object.lat = reader.readDouble(offsets[1]);
  object.long = reader.readDouble(offsets[2]);
  return object;
}

P _zipTrackPosDeserializeProp<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.readDouble(offset)) as P;
    case 2:
      return (reader.readDouble(offset)) as P;
    default:
      throw IsarError('Unknown property with id $propertyId');
  }
}

extension ZipTrackPosQueryFilter
    on QueryBuilder<ZipTrackPos, ZipTrackPos, QFilterCondition> {
  QueryBuilder<ZipTrackPos, ZipTrackPos, QAfterFilterCondition> accEqualTo(
      int value) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'acc',
        value: value,
      ));
    });
  }

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

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

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

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

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

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

  QueryBuilder<ZipTrackPos, ZipTrackPos, QAfterFilterCondition> latBetween(
    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'lat',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        epsilon: epsilon,
      ));
    });
  }

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

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

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

  QueryBuilder<ZipTrackPos, ZipTrackPos, QAfterFilterCondition> longBetween(
    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'long',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        epsilon: epsilon,
      ));
    });
  }
}

extension ZipTrackPosQueryObject
    on QueryBuilder<ZipTrackPos, ZipTrackPos, QFilterCondition> {}

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

ZipMessage _$ZipMessageFromJson(Map<String, dynamic> json) => ZipMessage()
  ..setPos = json['set_pos'] == null
      ? null
      : ZipSetPos.fromJson(json['set_pos'] as Map<String, dynamic>)
  ..reqZip = json['req_zip'] == null
      ? null
      : ZipReqZip.fromJson(json['req_zip'] as Map<String, dynamic>);

Map<String, dynamic> _$ZipMessageToJson(ZipMessage instance) =>
    <String, dynamic>{
      'set_pos': instance.setPos,
      'req_zip': instance.reqZip,
    };

ZipReqZip _$ZipReqZipFromJson(Map<String, dynamic> json) => ZipReqZip()
  ..id = json['id'] as int
  ..zip = json['zip'] as String;

Map<String, dynamic> _$ZipReqZipToJson(ZipReqZip instance) => <String, dynamic>{
      'id': instance.id,
      'zip': instance.zip,
    };

ZipSetPos _$ZipSetPosFromJson(Map<String, dynamic> json) => ZipSetPos()
  ..zip = json['zip'] as String
  ..track = json['track'] == null
      ? null
      : ZipTrack.fromJson(json['track'] as Map<String, dynamic>);

Map<String, dynamic> _$ZipSetPosToJson(ZipSetPos instance) => <String, dynamic>{
      'zip': instance.zip,
      'track': instance.track,
    };

ZipTrack _$ZipTrackFromJson(Map<String, dynamic> json) => ZipTrack()
  ..time = json['time'] as String
  ..pos = json['pos'] == null
      ? null
      : ZipTrackPos.fromJson(json['pos'] as Map<String, dynamic>);

Map<String, dynamic> _$ZipTrackToJson(ZipTrack instance) => <String, dynamic>{
      'time': instance.time,
      'pos': instance.pos,
    };

ZipTrackPos _$ZipTrackPosFromJson(Map<String, dynamic> json) => ZipTrackPos()
  ..lat = (json['lat'] as num).toDouble()
  ..long = (json['long'] as num).toDouble()
  ..acc = json['acc'] as int;

Map<String, dynamic> _$ZipTrackPosToJson(ZipTrackPos instance) =>
    <String, dynamic>{
      'lat': instance.lat,
      'long': instance.long,
      'acc': instance.acc,
    };