immich/mobile/lib/shared/models/logger_message.model.g.dart

// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'logger_message.model.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 GetLoggerMessageCollection on Isar {
  IsarCollection<LoggerMessage> get loggerMessages => this.collection();
}

const LoggerMessageSchema = CollectionSchema(
  name: r'LoggerMessage',
  id: -1606100856208753787,
  properties: {
    r'context1': PropertySchema(
      id: 0,
      name: r'context1',
      type: IsarType.string,
    ),
    r'context2': PropertySchema(
      id: 1,
      name: r'context2',
      type: IsarType.string,
    ),
    r'createdAt': PropertySchema(
      id: 2,
      name: r'createdAt',
      type: IsarType.dateTime,
    ),
    r'level': PropertySchema(
      id: 3,
      name: r'level',
      type: IsarType.byte,
      enumMap: _LoggerMessagelevelEnumValueMap,
    ),
    r'message': PropertySchema(
      id: 4,
      name: r'message',
      type: IsarType.string,
    )
  },
  estimateSize: _loggerMessageEstimateSize,
  serialize: _loggerMessageSerialize,
  deserialize: _loggerMessageDeserialize,
  deserializeProp: _loggerMessageDeserializeProp,
  idName: r'id',
  indexes: {},
  links: {},
  embeddedSchemas: {},
  getId: _loggerMessageGetId,
  getLinks: _loggerMessageGetLinks,
  attach: _loggerMessageAttach,
  version: '3.1.0+1',
);

int _loggerMessageEstimateSize(
  LoggerMessage object,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  var bytesCount = offsets.last;
  {
    final value = object.context1;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  {
    final value = object.context2;
    if (value != null) {
      bytesCount += 3 + value.length * 3;
    }
  }
  bytesCount += 3 + object.message.length * 3;
  return bytesCount;
}

void _loggerMessageSerialize(
  LoggerMessage object,
  IsarWriter writer,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  writer.writeString(offsets[0], object.context1);
  writer.writeString(offsets[1], object.context2);
  writer.writeDateTime(offsets[2], object.createdAt);
  writer.writeByte(offsets[3], object.level.index);
  writer.writeString(offsets[4], object.message);
}

LoggerMessage _loggerMessageDeserialize(
  Id id,
  IsarReader reader,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  final object = LoggerMessage(
    context1: reader.readStringOrNull(offsets[0]),
    context2: reader.readStringOrNull(offsets[1]),
    createdAt: reader.readDateTime(offsets[2]),
    level: _LoggerMessagelevelValueEnumMap[reader.readByteOrNull(offsets[3])] ??
        LogLevel.ALL,
    message: reader.readString(offsets[4]),
  );
  object.id = id;
  return object;
}

P _loggerMessageDeserializeProp<P>(
  IsarReader reader,
  int propertyId,
  int offset,
  Map<Type, List<int>> allOffsets,
) {
  switch (propertyId) {
    case 0:
      return (reader.readStringOrNull(offset)) as P;
    case 1:
      return (reader.readStringOrNull(offset)) as P;
    case 2:
      return (reader.readDateTime(offset)) as P;
    case 3:
      return (_LoggerMessagelevelValueEnumMap[reader.readByteOrNull(offset)] ??
          LogLevel.ALL) as P;
    case 4:
      return (reader.readString(offset)) as P;
    default:
      throw IsarError('Unknown property with id $propertyId');
  }
}

const _LoggerMessagelevelEnumValueMap = {
  'ALL': 0,
  'FINEST': 1,
  'FINER': 2,
  'FINE': 3,
  'CONFIG': 4,
  'INFO': 5,
  'WARNING': 6,
  'SEVERE': 7,
  'SHOUT': 8,
  'OFF': 9,
};
const _LoggerMessagelevelValueEnumMap = {
  0: LogLevel.ALL,
  1: LogLevel.FINEST,
  2: LogLevel.FINER,
  3: LogLevel.FINE,
  4: LogLevel.CONFIG,
  5: LogLevel.INFO,
  6: LogLevel.WARNING,
  7: LogLevel.SEVERE,
  8: LogLevel.SHOUT,
  9: LogLevel.OFF,
};

Id _loggerMessageGetId(LoggerMessage object) {
  return object.id;
}

List<IsarLinkBase<dynamic>> _loggerMessageGetLinks(LoggerMessage object) {
  return [];
}

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

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

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

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

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

  QueryBuilder<LoggerMessage, LoggerMessage, 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,
      ));
    });
  }
}

extension LoggerMessageQueryFilter
    on QueryBuilder<LoggerMessage, LoggerMessage, QFilterCondition> {
  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      context1IsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'context1',
      ));
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      context1IsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'context1',
      ));
    });
  }

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

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

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

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      context1Between(
    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'context1',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      context1IsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'context1',
        value: '',
      ));
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      context1IsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'context1',
        value: '',
      ));
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      context2IsNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNull(
        property: r'context2',
      ));
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      context2IsNotNull() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(const FilterCondition.isNotNull(
        property: r'context2',
      ));
    });
  }

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

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

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

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      context2Between(
    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'context2',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      context2IsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'context2',
        value: '',
      ));
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      context2IsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'context2',
        value: '',
      ));
    });
  }

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

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

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

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      levelGreaterThan(
    LogLevel value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        include: include,
        property: r'level',
        value: value,
      ));
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      levelLessThan(
    LogLevel value, {
    bool include = false,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.lessThan(
        include: include,
        property: r'level',
        value: value,
      ));
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      levelBetween(
    LogLevel lower,
    LogLevel upper, {
    bool includeLower = true,
    bool includeUpper = true,
  }) {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.between(
        property: r'level',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
      ));
    });
  }

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

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

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

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      messageBetween(
    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'message',
        lower: lower,
        includeLower: includeLower,
        upper: upper,
        includeUpper: includeUpper,
        caseSensitive: caseSensitive,
      ));
    });
  }

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

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

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

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

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      messageIsEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.equalTo(
        property: r'message',
        value: '',
      ));
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterFilterCondition>
      messageIsNotEmpty() {
    return QueryBuilder.apply(this, (query) {
      return query.addFilterCondition(FilterCondition.greaterThan(
        property: r'message',
        value: '',
      ));
    });
  }
}

extension LoggerMessageQueryObject
    on QueryBuilder<LoggerMessage, LoggerMessage, QFilterCondition> {}

extension LoggerMessageQueryLinks
    on QueryBuilder<LoggerMessage, LoggerMessage, QFilterCondition> {}

extension LoggerMessageQuerySortBy
    on QueryBuilder<LoggerMessage, LoggerMessage, QSortBy> {
  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy> sortByContext1() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'context1', Sort.asc);
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy>
      sortByContext1Desc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'context1', Sort.desc);
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy> sortByContext2() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'context2', Sort.asc);
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy>
      sortByContext2Desc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'context2', Sort.desc);
    });
  }

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

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

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy> sortByLevel() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'level', Sort.asc);
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy> sortByLevelDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'level', Sort.desc);
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy> sortByMessage() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'message', Sort.asc);
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy> sortByMessageDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'message', Sort.desc);
    });
  }
}

extension LoggerMessageQuerySortThenBy
    on QueryBuilder<LoggerMessage, LoggerMessage, QSortThenBy> {
  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy> thenByContext1() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'context1', Sort.asc);
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy>
      thenByContext1Desc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'context1', Sort.desc);
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy> thenByContext2() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'context2', Sort.asc);
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy>
      thenByContext2Desc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'context2', Sort.desc);
    });
  }

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

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

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

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

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy> thenByLevel() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'level', Sort.asc);
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy> thenByLevelDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'level', Sort.desc);
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy> thenByMessage() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'message', Sort.asc);
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QAfterSortBy> thenByMessageDesc() {
    return QueryBuilder.apply(this, (query) {
      return query.addSortBy(r'message', Sort.desc);
    });
  }
}

extension LoggerMessageQueryWhereDistinct
    on QueryBuilder<LoggerMessage, LoggerMessage, QDistinct> {
  QueryBuilder<LoggerMessage, LoggerMessage, QDistinct> distinctByContext1(
      {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'context1', caseSensitive: caseSensitive);
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QDistinct> distinctByContext2(
      {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'context2', caseSensitive: caseSensitive);
    });
  }

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

  QueryBuilder<LoggerMessage, LoggerMessage, QDistinct> distinctByLevel() {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'level');
    });
  }

  QueryBuilder<LoggerMessage, LoggerMessage, QDistinct> distinctByMessage(
      {bool caseSensitive = true}) {
    return QueryBuilder.apply(this, (query) {
      return query.addDistinctBy(r'message', caseSensitive: caseSensitive);
    });
  }
}

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

  QueryBuilder<LoggerMessage, String?, QQueryOperations> context1Property() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'context1');
    });
  }

  QueryBuilder<LoggerMessage, String?, QQueryOperations> context2Property() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'context2');
    });
  }

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

  QueryBuilder<LoggerMessage, LogLevel, QQueryOperations> levelProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'level');
    });
  }

  QueryBuilder<LoggerMessage, String, QQueryOperations> messageProperty() {
    return QueryBuilder.apply(this, (query) {
      return query.addPropertyName(r'message');
    });
  }
}