// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'app_database.dart';

// ignore_for_file: type=lint
class $EnfantsTable extends Enfants with TableInfo<$EnfantsTable, Enfant> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $EnfantsTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<int> id = GeneratedColumn<int>(
    'id',
    aliasedName,
    false,
    hasAutoIncrement: true,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'PRIMARY KEY AUTOINCREMENT',
    ),
  );
  static const VerificationMeta _prenomMeta = const VerificationMeta('prenom');
  @override
  late final GeneratedColumn<String> prenom = GeneratedColumn<String>(
    'prenom',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _dateNaissanceMeta = const VerificationMeta(
    'dateNaissance',
  );
  @override
  late final GeneratedColumn<String> dateNaissance = GeneratedColumn<String>(
    'date_naissance',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
  );
  static const VerificationMeta _scoreMeta = const VerificationMeta('score');
  @override
  late final GeneratedColumn<int> score = GeneratedColumn<int>(
    'score',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultValue: const Constant(0),
  );
  static const VerificationMeta _couleurMeta = const VerificationMeta(
    'couleur',
  );
  @override
  late final GeneratedColumn<String> couleur = GeneratedColumn<String>(
    'couleur',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    defaultValue: const Constant('#6C63FF'),
  );
  static const VerificationMeta _ordreMeta = const VerificationMeta('ordre');
  @override
  late final GeneratedColumn<int> ordre = GeneratedColumn<int>(
    'ordre',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultValue: const Constant(0),
  );
  @override
  List<GeneratedColumn> get $columns => [
    id,
    prenom,
    dateNaissance,
    score,
    couleur,
    ordre,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'enfants';
  @override
  VerificationContext validateIntegrity(
    Insertable<Enfant> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    }
    if (data.containsKey('prenom')) {
      context.handle(
        _prenomMeta,
        prenom.isAcceptableOrUnknown(data['prenom']!, _prenomMeta),
      );
    } else if (isInserting) {
      context.missing(_prenomMeta);
    }
    if (data.containsKey('date_naissance')) {
      context.handle(
        _dateNaissanceMeta,
        dateNaissance.isAcceptableOrUnknown(
          data['date_naissance']!,
          _dateNaissanceMeta,
        ),
      );
    }
    if (data.containsKey('score')) {
      context.handle(
        _scoreMeta,
        score.isAcceptableOrUnknown(data['score']!, _scoreMeta),
      );
    }
    if (data.containsKey('couleur')) {
      context.handle(
        _couleurMeta,
        couleur.isAcceptableOrUnknown(data['couleur']!, _couleurMeta),
      );
    }
    if (data.containsKey('ordre')) {
      context.handle(
        _ordreMeta,
        ordre.isAcceptableOrUnknown(data['ordre']!, _ordreMeta),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  List<Set<GeneratedColumn>> get uniqueKeys => [
    {prenom},
  ];
  @override
  Enfant map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return Enfant(
      id: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}id'],
      )!,
      prenom: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}prenom'],
      )!,
      dateNaissance: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}date_naissance'],
      ),
      score: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}score'],
      )!,
      couleur: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}couleur'],
      )!,
      ordre: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}ordre'],
      )!,
    );
  }

  @override
  $EnfantsTable createAlias(String alias) {
    return $EnfantsTable(attachedDatabase, alias);
  }
}

class Enfant extends DataClass implements Insertable<Enfant> {
  final int id;
  final String prenom;
  final String? dateNaissance;
  final int score;
  final String couleur;
  final int ordre;
  const Enfant({
    required this.id,
    required this.prenom,
    this.dateNaissance,
    required this.score,
    required this.couleur,
    required this.ordre,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<int>(id);
    map['prenom'] = Variable<String>(prenom);
    if (!nullToAbsent || dateNaissance != null) {
      map['date_naissance'] = Variable<String>(dateNaissance);
    }
    map['score'] = Variable<int>(score);
    map['couleur'] = Variable<String>(couleur);
    map['ordre'] = Variable<int>(ordre);
    return map;
  }

  EnfantsCompanion toCompanion(bool nullToAbsent) {
    return EnfantsCompanion(
      id: Value(id),
      prenom: Value(prenom),
      dateNaissance: dateNaissance == null && nullToAbsent
          ? const Value.absent()
          : Value(dateNaissance),
      score: Value(score),
      couleur: Value(couleur),
      ordre: Value(ordre),
    );
  }

  factory Enfant.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return Enfant(
      id: serializer.fromJson<int>(json['id']),
      prenom: serializer.fromJson<String>(json['prenom']),
      dateNaissance: serializer.fromJson<String?>(json['dateNaissance']),
      score: serializer.fromJson<int>(json['score']),
      couleur: serializer.fromJson<String>(json['couleur']),
      ordre: serializer.fromJson<int>(json['ordre']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'id': serializer.toJson<int>(id),
      'prenom': serializer.toJson<String>(prenom),
      'dateNaissance': serializer.toJson<String?>(dateNaissance),
      'score': serializer.toJson<int>(score),
      'couleur': serializer.toJson<String>(couleur),
      'ordre': serializer.toJson<int>(ordre),
    };
  }

  Enfant copyWith({
    int? id,
    String? prenom,
    Value<String?> dateNaissance = const Value.absent(),
    int? score,
    String? couleur,
    int? ordre,
  }) => Enfant(
    id: id ?? this.id,
    prenom: prenom ?? this.prenom,
    dateNaissance: dateNaissance.present
        ? dateNaissance.value
        : this.dateNaissance,
    score: score ?? this.score,
    couleur: couleur ?? this.couleur,
    ordre: ordre ?? this.ordre,
  );
  Enfant copyWithCompanion(EnfantsCompanion data) {
    return Enfant(
      id: data.id.present ? data.id.value : this.id,
      prenom: data.prenom.present ? data.prenom.value : this.prenom,
      dateNaissance: data.dateNaissance.present
          ? data.dateNaissance.value
          : this.dateNaissance,
      score: data.score.present ? data.score.value : this.score,
      couleur: data.couleur.present ? data.couleur.value : this.couleur,
      ordre: data.ordre.present ? data.ordre.value : this.ordre,
    );
  }

  @override
  String toString() {
    return (StringBuffer('Enfant(')
          ..write('id: $id, ')
          ..write('prenom: $prenom, ')
          ..write('dateNaissance: $dateNaissance, ')
          ..write('score: $score, ')
          ..write('couleur: $couleur, ')
          ..write('ordre: $ordre')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode =>
      Object.hash(id, prenom, dateNaissance, score, couleur, ordre);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is Enfant &&
          other.id == this.id &&
          other.prenom == this.prenom &&
          other.dateNaissance == this.dateNaissance &&
          other.score == this.score &&
          other.couleur == this.couleur &&
          other.ordre == this.ordre);
}

class EnfantsCompanion extends UpdateCompanion<Enfant> {
  final Value<int> id;
  final Value<String> prenom;
  final Value<String?> dateNaissance;
  final Value<int> score;
  final Value<String> couleur;
  final Value<int> ordre;
  const EnfantsCompanion({
    this.id = const Value.absent(),
    this.prenom = const Value.absent(),
    this.dateNaissance = const Value.absent(),
    this.score = const Value.absent(),
    this.couleur = const Value.absent(),
    this.ordre = const Value.absent(),
  });
  EnfantsCompanion.insert({
    this.id = const Value.absent(),
    required String prenom,
    this.dateNaissance = const Value.absent(),
    this.score = const Value.absent(),
    this.couleur = const Value.absent(),
    this.ordre = const Value.absent(),
  }) : prenom = Value(prenom);
  static Insertable<Enfant> custom({
    Expression<int>? id,
    Expression<String>? prenom,
    Expression<String>? dateNaissance,
    Expression<int>? score,
    Expression<String>? couleur,
    Expression<int>? ordre,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (prenom != null) 'prenom': prenom,
      if (dateNaissance != null) 'date_naissance': dateNaissance,
      if (score != null) 'score': score,
      if (couleur != null) 'couleur': couleur,
      if (ordre != null) 'ordre': ordre,
    });
  }

  EnfantsCompanion copyWith({
    Value<int>? id,
    Value<String>? prenom,
    Value<String?>? dateNaissance,
    Value<int>? score,
    Value<String>? couleur,
    Value<int>? ordre,
  }) {
    return EnfantsCompanion(
      id: id ?? this.id,
      prenom: prenom ?? this.prenom,
      dateNaissance: dateNaissance ?? this.dateNaissance,
      score: score ?? this.score,
      couleur: couleur ?? this.couleur,
      ordre: ordre ?? this.ordre,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<int>(id.value);
    }
    if (prenom.present) {
      map['prenom'] = Variable<String>(prenom.value);
    }
    if (dateNaissance.present) {
      map['date_naissance'] = Variable<String>(dateNaissance.value);
    }
    if (score.present) {
      map['score'] = Variable<int>(score.value);
    }
    if (couleur.present) {
      map['couleur'] = Variable<String>(couleur.value);
    }
    if (ordre.present) {
      map['ordre'] = Variable<int>(ordre.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('EnfantsCompanion(')
          ..write('id: $id, ')
          ..write('prenom: $prenom, ')
          ..write('dateNaissance: $dateNaissance, ')
          ..write('score: $score, ')
          ..write('couleur: $couleur, ')
          ..write('ordre: $ordre')
          ..write(')'))
        .toString();
  }
}

class $ReglesTable extends Regles with TableInfo<$ReglesTable, Regle> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $ReglesTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<int> id = GeneratedColumn<int>(
    'id',
    aliasedName,
    false,
    hasAutoIncrement: true,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'PRIMARY KEY AUTOINCREMENT',
    ),
  );
  static const VerificationMeta _libelleMeta = const VerificationMeta(
    'libelle',
  );
  @override
  late final GeneratedColumn<String> libelle = GeneratedColumn<String>(
    'libelle',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _pointsMeta = const VerificationMeta('points');
  @override
  late final GeneratedColumn<int> points = GeneratedColumn<int>(
    'points',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _iconeMeta = const VerificationMeta('icone');
  @override
  late final GeneratedColumn<String> icone = GeneratedColumn<String>(
    'icone',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    defaultValue: const Constant('⭐'),
  );
  static const VerificationMeta _actifMeta = const VerificationMeta('actif');
  @override
  late final GeneratedColumn<bool> actif = GeneratedColumn<bool>(
    'actif',
    aliasedName,
    false,
    type: DriftSqlType.bool,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'CHECK ("actif" IN (0, 1))',
    ),
    defaultValue: const Constant(true),
  );
  static const VerificationMeta _ordreMeta = const VerificationMeta('ordre');
  @override
  late final GeneratedColumn<int> ordre = GeneratedColumn<int>(
    'ordre',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultValue: const Constant(0),
  );
  static const VerificationMeta _familleMeta = const VerificationMeta(
    'famille',
  );
  @override
  late final GeneratedColumn<String> famille = GeneratedColumn<String>(
    'famille',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    defaultValue: const Constant('📋 Autre'),
  );
  static const VerificationMeta _familleOrdreMeta = const VerificationMeta(
    'familleOrdre',
  );
  @override
  late final GeneratedColumn<int> familleOrdre = GeneratedColumn<int>(
    'famille_ordre',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultValue: const Constant(99),
  );
  @override
  List<GeneratedColumn> get $columns => [
    id,
    libelle,
    points,
    icone,
    actif,
    ordre,
    famille,
    familleOrdre,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'regles';
  @override
  VerificationContext validateIntegrity(
    Insertable<Regle> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    }
    if (data.containsKey('libelle')) {
      context.handle(
        _libelleMeta,
        libelle.isAcceptableOrUnknown(data['libelle']!, _libelleMeta),
      );
    } else if (isInserting) {
      context.missing(_libelleMeta);
    }
    if (data.containsKey('points')) {
      context.handle(
        _pointsMeta,
        points.isAcceptableOrUnknown(data['points']!, _pointsMeta),
      );
    } else if (isInserting) {
      context.missing(_pointsMeta);
    }
    if (data.containsKey('icone')) {
      context.handle(
        _iconeMeta,
        icone.isAcceptableOrUnknown(data['icone']!, _iconeMeta),
      );
    }
    if (data.containsKey('actif')) {
      context.handle(
        _actifMeta,
        actif.isAcceptableOrUnknown(data['actif']!, _actifMeta),
      );
    }
    if (data.containsKey('ordre')) {
      context.handle(
        _ordreMeta,
        ordre.isAcceptableOrUnknown(data['ordre']!, _ordreMeta),
      );
    }
    if (data.containsKey('famille')) {
      context.handle(
        _familleMeta,
        famille.isAcceptableOrUnknown(data['famille']!, _familleMeta),
      );
    }
    if (data.containsKey('famille_ordre')) {
      context.handle(
        _familleOrdreMeta,
        familleOrdre.isAcceptableOrUnknown(
          data['famille_ordre']!,
          _familleOrdreMeta,
        ),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  Regle map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return Regle(
      id: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}id'],
      )!,
      libelle: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}libelle'],
      )!,
      points: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}points'],
      )!,
      icone: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}icone'],
      )!,
      actif: attachedDatabase.typeMapping.read(
        DriftSqlType.bool,
        data['${effectivePrefix}actif'],
      )!,
      ordre: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}ordre'],
      )!,
      famille: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}famille'],
      )!,
      familleOrdre: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}famille_ordre'],
      )!,
    );
  }

  @override
  $ReglesTable createAlias(String alias) {
    return $ReglesTable(attachedDatabase, alias);
  }
}

class Regle extends DataClass implements Insertable<Regle> {
  final int id;
  final String libelle;
  final int points;
  final String icone;
  final bool actif;
  final int ordre;
  final String famille;
  final int familleOrdre;
  const Regle({
    required this.id,
    required this.libelle,
    required this.points,
    required this.icone,
    required this.actif,
    required this.ordre,
    required this.famille,
    required this.familleOrdre,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<int>(id);
    map['libelle'] = Variable<String>(libelle);
    map['points'] = Variable<int>(points);
    map['icone'] = Variable<String>(icone);
    map['actif'] = Variable<bool>(actif);
    map['ordre'] = Variable<int>(ordre);
    map['famille'] = Variable<String>(famille);
    map['famille_ordre'] = Variable<int>(familleOrdre);
    return map;
  }

  ReglesCompanion toCompanion(bool nullToAbsent) {
    return ReglesCompanion(
      id: Value(id),
      libelle: Value(libelle),
      points: Value(points),
      icone: Value(icone),
      actif: Value(actif),
      ordre: Value(ordre),
      famille: Value(famille),
      familleOrdre: Value(familleOrdre),
    );
  }

  factory Regle.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return Regle(
      id: serializer.fromJson<int>(json['id']),
      libelle: serializer.fromJson<String>(json['libelle']),
      points: serializer.fromJson<int>(json['points']),
      icone: serializer.fromJson<String>(json['icone']),
      actif: serializer.fromJson<bool>(json['actif']),
      ordre: serializer.fromJson<int>(json['ordre']),
      famille: serializer.fromJson<String>(json['famille']),
      familleOrdre: serializer.fromJson<int>(json['familleOrdre']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'id': serializer.toJson<int>(id),
      'libelle': serializer.toJson<String>(libelle),
      'points': serializer.toJson<int>(points),
      'icone': serializer.toJson<String>(icone),
      'actif': serializer.toJson<bool>(actif),
      'ordre': serializer.toJson<int>(ordre),
      'famille': serializer.toJson<String>(famille),
      'familleOrdre': serializer.toJson<int>(familleOrdre),
    };
  }

  Regle copyWith({
    int? id,
    String? libelle,
    int? points,
    String? icone,
    bool? actif,
    int? ordre,
    String? famille,
    int? familleOrdre,
  }) => Regle(
    id: id ?? this.id,
    libelle: libelle ?? this.libelle,
    points: points ?? this.points,
    icone: icone ?? this.icone,
    actif: actif ?? this.actif,
    ordre: ordre ?? this.ordre,
    famille: famille ?? this.famille,
    familleOrdre: familleOrdre ?? this.familleOrdre,
  );
  Regle copyWithCompanion(ReglesCompanion data) {
    return Regle(
      id: data.id.present ? data.id.value : this.id,
      libelle: data.libelle.present ? data.libelle.value : this.libelle,
      points: data.points.present ? data.points.value : this.points,
      icone: data.icone.present ? data.icone.value : this.icone,
      actif: data.actif.present ? data.actif.value : this.actif,
      ordre: data.ordre.present ? data.ordre.value : this.ordre,
      famille: data.famille.present ? data.famille.value : this.famille,
      familleOrdre: data.familleOrdre.present
          ? data.familleOrdre.value
          : this.familleOrdre,
    );
  }

  @override
  String toString() {
    return (StringBuffer('Regle(')
          ..write('id: $id, ')
          ..write('libelle: $libelle, ')
          ..write('points: $points, ')
          ..write('icone: $icone, ')
          ..write('actif: $actif, ')
          ..write('ordre: $ordre, ')
          ..write('famille: $famille, ')
          ..write('familleOrdre: $familleOrdre')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(
    id,
    libelle,
    points,
    icone,
    actif,
    ordre,
    famille,
    familleOrdre,
  );
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is Regle &&
          other.id == this.id &&
          other.libelle == this.libelle &&
          other.points == this.points &&
          other.icone == this.icone &&
          other.actif == this.actif &&
          other.ordre == this.ordre &&
          other.famille == this.famille &&
          other.familleOrdre == this.familleOrdre);
}

class ReglesCompanion extends UpdateCompanion<Regle> {
  final Value<int> id;
  final Value<String> libelle;
  final Value<int> points;
  final Value<String> icone;
  final Value<bool> actif;
  final Value<int> ordre;
  final Value<String> famille;
  final Value<int> familleOrdre;
  const ReglesCompanion({
    this.id = const Value.absent(),
    this.libelle = const Value.absent(),
    this.points = const Value.absent(),
    this.icone = const Value.absent(),
    this.actif = const Value.absent(),
    this.ordre = const Value.absent(),
    this.famille = const Value.absent(),
    this.familleOrdre = const Value.absent(),
  });
  ReglesCompanion.insert({
    this.id = const Value.absent(),
    required String libelle,
    required int points,
    this.icone = const Value.absent(),
    this.actif = const Value.absent(),
    this.ordre = const Value.absent(),
    this.famille = const Value.absent(),
    this.familleOrdre = const Value.absent(),
  }) : libelle = Value(libelle),
       points = Value(points);
  static Insertable<Regle> custom({
    Expression<int>? id,
    Expression<String>? libelle,
    Expression<int>? points,
    Expression<String>? icone,
    Expression<bool>? actif,
    Expression<int>? ordre,
    Expression<String>? famille,
    Expression<int>? familleOrdre,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (libelle != null) 'libelle': libelle,
      if (points != null) 'points': points,
      if (icone != null) 'icone': icone,
      if (actif != null) 'actif': actif,
      if (ordre != null) 'ordre': ordre,
      if (famille != null) 'famille': famille,
      if (familleOrdre != null) 'famille_ordre': familleOrdre,
    });
  }

  ReglesCompanion copyWith({
    Value<int>? id,
    Value<String>? libelle,
    Value<int>? points,
    Value<String>? icone,
    Value<bool>? actif,
    Value<int>? ordre,
    Value<String>? famille,
    Value<int>? familleOrdre,
  }) {
    return ReglesCompanion(
      id: id ?? this.id,
      libelle: libelle ?? this.libelle,
      points: points ?? this.points,
      icone: icone ?? this.icone,
      actif: actif ?? this.actif,
      ordre: ordre ?? this.ordre,
      famille: famille ?? this.famille,
      familleOrdre: familleOrdre ?? this.familleOrdre,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<int>(id.value);
    }
    if (libelle.present) {
      map['libelle'] = Variable<String>(libelle.value);
    }
    if (points.present) {
      map['points'] = Variable<int>(points.value);
    }
    if (icone.present) {
      map['icone'] = Variable<String>(icone.value);
    }
    if (actif.present) {
      map['actif'] = Variable<bool>(actif.value);
    }
    if (ordre.present) {
      map['ordre'] = Variable<int>(ordre.value);
    }
    if (famille.present) {
      map['famille'] = Variable<String>(famille.value);
    }
    if (familleOrdre.present) {
      map['famille_ordre'] = Variable<int>(familleOrdre.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('ReglesCompanion(')
          ..write('id: $id, ')
          ..write('libelle: $libelle, ')
          ..write('points: $points, ')
          ..write('icone: $icone, ')
          ..write('actif: $actif, ')
          ..write('ordre: $ordre, ')
          ..write('famille: $famille, ')
          ..write('familleOrdre: $familleOrdre')
          ..write(')'))
        .toString();
  }
}

class $RecompensesTable extends Recompenses
    with TableInfo<$RecompensesTable, Recompense> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $RecompensesTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<int> id = GeneratedColumn<int>(
    'id',
    aliasedName,
    false,
    hasAutoIncrement: true,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'PRIMARY KEY AUTOINCREMENT',
    ),
  );
  static const VerificationMeta _libelleMeta = const VerificationMeta(
    'libelle',
  );
  @override
  late final GeneratedColumn<String> libelle = GeneratedColumn<String>(
    'libelle',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _coutPointsMeta = const VerificationMeta(
    'coutPoints',
  );
  @override
  late final GeneratedColumn<int> coutPoints = GeneratedColumn<int>(
    'cout_points',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _iconeMeta = const VerificationMeta('icone');
  @override
  late final GeneratedColumn<String> icone = GeneratedColumn<String>(
    'icone',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    defaultValue: const Constant('🎁'),
  );
  static const VerificationMeta _actifMeta = const VerificationMeta('actif');
  @override
  late final GeneratedColumn<bool> actif = GeneratedColumn<bool>(
    'actif',
    aliasedName,
    false,
    type: DriftSqlType.bool,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'CHECK ("actif" IN (0, 1))',
    ),
    defaultValue: const Constant(true),
  );
  static const VerificationMeta _ordreMeta = const VerificationMeta('ordre');
  @override
  late final GeneratedColumn<int> ordre = GeneratedColumn<int>(
    'ordre',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultValue: const Constant(0),
  );
  @override
  List<GeneratedColumn> get $columns => [
    id,
    libelle,
    coutPoints,
    icone,
    actif,
    ordre,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'recompenses';
  @override
  VerificationContext validateIntegrity(
    Insertable<Recompense> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    }
    if (data.containsKey('libelle')) {
      context.handle(
        _libelleMeta,
        libelle.isAcceptableOrUnknown(data['libelle']!, _libelleMeta),
      );
    } else if (isInserting) {
      context.missing(_libelleMeta);
    }
    if (data.containsKey('cout_points')) {
      context.handle(
        _coutPointsMeta,
        coutPoints.isAcceptableOrUnknown(data['cout_points']!, _coutPointsMeta),
      );
    } else if (isInserting) {
      context.missing(_coutPointsMeta);
    }
    if (data.containsKey('icone')) {
      context.handle(
        _iconeMeta,
        icone.isAcceptableOrUnknown(data['icone']!, _iconeMeta),
      );
    }
    if (data.containsKey('actif')) {
      context.handle(
        _actifMeta,
        actif.isAcceptableOrUnknown(data['actif']!, _actifMeta),
      );
    }
    if (data.containsKey('ordre')) {
      context.handle(
        _ordreMeta,
        ordre.isAcceptableOrUnknown(data['ordre']!, _ordreMeta),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  Recompense map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return Recompense(
      id: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}id'],
      )!,
      libelle: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}libelle'],
      )!,
      coutPoints: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}cout_points'],
      )!,
      icone: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}icone'],
      )!,
      actif: attachedDatabase.typeMapping.read(
        DriftSqlType.bool,
        data['${effectivePrefix}actif'],
      )!,
      ordre: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}ordre'],
      )!,
    );
  }

  @override
  $RecompensesTable createAlias(String alias) {
    return $RecompensesTable(attachedDatabase, alias);
  }
}

class Recompense extends DataClass implements Insertable<Recompense> {
  final int id;
  final String libelle;
  final int coutPoints;
  final String icone;
  final bool actif;
  final int ordre;
  const Recompense({
    required this.id,
    required this.libelle,
    required this.coutPoints,
    required this.icone,
    required this.actif,
    required this.ordre,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<int>(id);
    map['libelle'] = Variable<String>(libelle);
    map['cout_points'] = Variable<int>(coutPoints);
    map['icone'] = Variable<String>(icone);
    map['actif'] = Variable<bool>(actif);
    map['ordre'] = Variable<int>(ordre);
    return map;
  }

  RecompensesCompanion toCompanion(bool nullToAbsent) {
    return RecompensesCompanion(
      id: Value(id),
      libelle: Value(libelle),
      coutPoints: Value(coutPoints),
      icone: Value(icone),
      actif: Value(actif),
      ordre: Value(ordre),
    );
  }

  factory Recompense.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return Recompense(
      id: serializer.fromJson<int>(json['id']),
      libelle: serializer.fromJson<String>(json['libelle']),
      coutPoints: serializer.fromJson<int>(json['coutPoints']),
      icone: serializer.fromJson<String>(json['icone']),
      actif: serializer.fromJson<bool>(json['actif']),
      ordre: serializer.fromJson<int>(json['ordre']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'id': serializer.toJson<int>(id),
      'libelle': serializer.toJson<String>(libelle),
      'coutPoints': serializer.toJson<int>(coutPoints),
      'icone': serializer.toJson<String>(icone),
      'actif': serializer.toJson<bool>(actif),
      'ordre': serializer.toJson<int>(ordre),
    };
  }

  Recompense copyWith({
    int? id,
    String? libelle,
    int? coutPoints,
    String? icone,
    bool? actif,
    int? ordre,
  }) => Recompense(
    id: id ?? this.id,
    libelle: libelle ?? this.libelle,
    coutPoints: coutPoints ?? this.coutPoints,
    icone: icone ?? this.icone,
    actif: actif ?? this.actif,
    ordre: ordre ?? this.ordre,
  );
  Recompense copyWithCompanion(RecompensesCompanion data) {
    return Recompense(
      id: data.id.present ? data.id.value : this.id,
      libelle: data.libelle.present ? data.libelle.value : this.libelle,
      coutPoints: data.coutPoints.present
          ? data.coutPoints.value
          : this.coutPoints,
      icone: data.icone.present ? data.icone.value : this.icone,
      actif: data.actif.present ? data.actif.value : this.actif,
      ordre: data.ordre.present ? data.ordre.value : this.ordre,
    );
  }

  @override
  String toString() {
    return (StringBuffer('Recompense(')
          ..write('id: $id, ')
          ..write('libelle: $libelle, ')
          ..write('coutPoints: $coutPoints, ')
          ..write('icone: $icone, ')
          ..write('actif: $actif, ')
          ..write('ordre: $ordre')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(id, libelle, coutPoints, icone, actif, ordre);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is Recompense &&
          other.id == this.id &&
          other.libelle == this.libelle &&
          other.coutPoints == this.coutPoints &&
          other.icone == this.icone &&
          other.actif == this.actif &&
          other.ordre == this.ordre);
}

class RecompensesCompanion extends UpdateCompanion<Recompense> {
  final Value<int> id;
  final Value<String> libelle;
  final Value<int> coutPoints;
  final Value<String> icone;
  final Value<bool> actif;
  final Value<int> ordre;
  const RecompensesCompanion({
    this.id = const Value.absent(),
    this.libelle = const Value.absent(),
    this.coutPoints = const Value.absent(),
    this.icone = const Value.absent(),
    this.actif = const Value.absent(),
    this.ordre = const Value.absent(),
  });
  RecompensesCompanion.insert({
    this.id = const Value.absent(),
    required String libelle,
    required int coutPoints,
    this.icone = const Value.absent(),
    this.actif = const Value.absent(),
    this.ordre = const Value.absent(),
  }) : libelle = Value(libelle),
       coutPoints = Value(coutPoints);
  static Insertable<Recompense> custom({
    Expression<int>? id,
    Expression<String>? libelle,
    Expression<int>? coutPoints,
    Expression<String>? icone,
    Expression<bool>? actif,
    Expression<int>? ordre,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (libelle != null) 'libelle': libelle,
      if (coutPoints != null) 'cout_points': coutPoints,
      if (icone != null) 'icone': icone,
      if (actif != null) 'actif': actif,
      if (ordre != null) 'ordre': ordre,
    });
  }

  RecompensesCompanion copyWith({
    Value<int>? id,
    Value<String>? libelle,
    Value<int>? coutPoints,
    Value<String>? icone,
    Value<bool>? actif,
    Value<int>? ordre,
  }) {
    return RecompensesCompanion(
      id: id ?? this.id,
      libelle: libelle ?? this.libelle,
      coutPoints: coutPoints ?? this.coutPoints,
      icone: icone ?? this.icone,
      actif: actif ?? this.actif,
      ordre: ordre ?? this.ordre,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<int>(id.value);
    }
    if (libelle.present) {
      map['libelle'] = Variable<String>(libelle.value);
    }
    if (coutPoints.present) {
      map['cout_points'] = Variable<int>(coutPoints.value);
    }
    if (icone.present) {
      map['icone'] = Variable<String>(icone.value);
    }
    if (actif.present) {
      map['actif'] = Variable<bool>(actif.value);
    }
    if (ordre.present) {
      map['ordre'] = Variable<int>(ordre.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('RecompensesCompanion(')
          ..write('id: $id, ')
          ..write('libelle: $libelle, ')
          ..write('coutPoints: $coutPoints, ')
          ..write('icone: $icone, ')
          ..write('actif: $actif, ')
          ..write('ordre: $ordre')
          ..write(')'))
        .toString();
  }
}

class $MouvementsTable extends Mouvements
    with TableInfo<$MouvementsTable, Mouvement> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $MouvementsTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<int> id = GeneratedColumn<int>(
    'id',
    aliasedName,
    false,
    hasAutoIncrement: true,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'PRIMARY KEY AUTOINCREMENT',
    ),
  );
  static const VerificationMeta _enfantIdMeta = const VerificationMeta(
    'enfantId',
  );
  @override
  late final GeneratedColumn<int> enfantId = GeneratedColumn<int>(
    'enfant_id',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'REFERENCES enfants (id)',
    ),
  );
  static const VerificationMeta _regleIdMeta = const VerificationMeta(
    'regleId',
  );
  @override
  late final GeneratedColumn<int> regleId = GeneratedColumn<int>(
    'regle_id',
    aliasedName,
    true,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'REFERENCES regles (id)',
    ),
  );
  static const VerificationMeta _recompenseIdMeta = const VerificationMeta(
    'recompenseId',
  );
  @override
  late final GeneratedColumn<int> recompenseId = GeneratedColumn<int>(
    'recompense_id',
    aliasedName,
    true,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'REFERENCES recompenses (id)',
    ),
  );
  static const VerificationMeta _deltaMeta = const VerificationMeta('delta');
  @override
  late final GeneratedColumn<int> delta = GeneratedColumn<int>(
    'delta',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _noteMeta = const VerificationMeta('note');
  @override
  late final GeneratedColumn<String> note = GeneratedColumn<String>(
    'note',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
  );
  static const VerificationMeta _creeLeMeta = const VerificationMeta('creeLe');
  @override
  late final GeneratedColumn<DateTime> creeLe = GeneratedColumn<DateTime>(
    'cree_le',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: false,
    defaultValue: currentDateAndTime,
  );
  static const VerificationMeta _annuleMeta = const VerificationMeta('annule');
  @override
  late final GeneratedColumn<bool> annule = GeneratedColumn<bool>(
    'annule',
    aliasedName,
    false,
    type: DriftSqlType.bool,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'CHECK ("annule" IN (0, 1))',
    ),
    defaultValue: const Constant(false),
  );
  @override
  List<GeneratedColumn> get $columns => [
    id,
    enfantId,
    regleId,
    recompenseId,
    delta,
    note,
    creeLe,
    annule,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'mouvements';
  @override
  VerificationContext validateIntegrity(
    Insertable<Mouvement> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    }
    if (data.containsKey('enfant_id')) {
      context.handle(
        _enfantIdMeta,
        enfantId.isAcceptableOrUnknown(data['enfant_id']!, _enfantIdMeta),
      );
    } else if (isInserting) {
      context.missing(_enfantIdMeta);
    }
    if (data.containsKey('regle_id')) {
      context.handle(
        _regleIdMeta,
        regleId.isAcceptableOrUnknown(data['regle_id']!, _regleIdMeta),
      );
    }
    if (data.containsKey('recompense_id')) {
      context.handle(
        _recompenseIdMeta,
        recompenseId.isAcceptableOrUnknown(
          data['recompense_id']!,
          _recompenseIdMeta,
        ),
      );
    }
    if (data.containsKey('delta')) {
      context.handle(
        _deltaMeta,
        delta.isAcceptableOrUnknown(data['delta']!, _deltaMeta),
      );
    } else if (isInserting) {
      context.missing(_deltaMeta);
    }
    if (data.containsKey('note')) {
      context.handle(
        _noteMeta,
        note.isAcceptableOrUnknown(data['note']!, _noteMeta),
      );
    }
    if (data.containsKey('cree_le')) {
      context.handle(
        _creeLeMeta,
        creeLe.isAcceptableOrUnknown(data['cree_le']!, _creeLeMeta),
      );
    }
    if (data.containsKey('annule')) {
      context.handle(
        _annuleMeta,
        annule.isAcceptableOrUnknown(data['annule']!, _annuleMeta),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  Mouvement map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return Mouvement(
      id: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}id'],
      )!,
      enfantId: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}enfant_id'],
      )!,
      regleId: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}regle_id'],
      ),
      recompenseId: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}recompense_id'],
      ),
      delta: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}delta'],
      )!,
      note: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}note'],
      ),
      creeLe: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}cree_le'],
      )!,
      annule: attachedDatabase.typeMapping.read(
        DriftSqlType.bool,
        data['${effectivePrefix}annule'],
      )!,
    );
  }

  @override
  $MouvementsTable createAlias(String alias) {
    return $MouvementsTable(attachedDatabase, alias);
  }
}

class Mouvement extends DataClass implements Insertable<Mouvement> {
  final int id;
  final int enfantId;
  final int? regleId;
  final int? recompenseId;
  final int delta;
  final String? note;
  final DateTime creeLe;
  final bool annule;
  const Mouvement({
    required this.id,
    required this.enfantId,
    this.regleId,
    this.recompenseId,
    required this.delta,
    this.note,
    required this.creeLe,
    required this.annule,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<int>(id);
    map['enfant_id'] = Variable<int>(enfantId);
    if (!nullToAbsent || regleId != null) {
      map['regle_id'] = Variable<int>(regleId);
    }
    if (!nullToAbsent || recompenseId != null) {
      map['recompense_id'] = Variable<int>(recompenseId);
    }
    map['delta'] = Variable<int>(delta);
    if (!nullToAbsent || note != null) {
      map['note'] = Variable<String>(note);
    }
    map['cree_le'] = Variable<DateTime>(creeLe);
    map['annule'] = Variable<bool>(annule);
    return map;
  }

  MouvementsCompanion toCompanion(bool nullToAbsent) {
    return MouvementsCompanion(
      id: Value(id),
      enfantId: Value(enfantId),
      regleId: regleId == null && nullToAbsent
          ? const Value.absent()
          : Value(regleId),
      recompenseId: recompenseId == null && nullToAbsent
          ? const Value.absent()
          : Value(recompenseId),
      delta: Value(delta),
      note: note == null && nullToAbsent ? const Value.absent() : Value(note),
      creeLe: Value(creeLe),
      annule: Value(annule),
    );
  }

  factory Mouvement.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return Mouvement(
      id: serializer.fromJson<int>(json['id']),
      enfantId: serializer.fromJson<int>(json['enfantId']),
      regleId: serializer.fromJson<int?>(json['regleId']),
      recompenseId: serializer.fromJson<int?>(json['recompenseId']),
      delta: serializer.fromJson<int>(json['delta']),
      note: serializer.fromJson<String?>(json['note']),
      creeLe: serializer.fromJson<DateTime>(json['creeLe']),
      annule: serializer.fromJson<bool>(json['annule']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'id': serializer.toJson<int>(id),
      'enfantId': serializer.toJson<int>(enfantId),
      'regleId': serializer.toJson<int?>(regleId),
      'recompenseId': serializer.toJson<int?>(recompenseId),
      'delta': serializer.toJson<int>(delta),
      'note': serializer.toJson<String?>(note),
      'creeLe': serializer.toJson<DateTime>(creeLe),
      'annule': serializer.toJson<bool>(annule),
    };
  }

  Mouvement copyWith({
    int? id,
    int? enfantId,
    Value<int?> regleId = const Value.absent(),
    Value<int?> recompenseId = const Value.absent(),
    int? delta,
    Value<String?> note = const Value.absent(),
    DateTime? creeLe,
    bool? annule,
  }) => Mouvement(
    id: id ?? this.id,
    enfantId: enfantId ?? this.enfantId,
    regleId: regleId.present ? regleId.value : this.regleId,
    recompenseId: recompenseId.present ? recompenseId.value : this.recompenseId,
    delta: delta ?? this.delta,
    note: note.present ? note.value : this.note,
    creeLe: creeLe ?? this.creeLe,
    annule: annule ?? this.annule,
  );
  Mouvement copyWithCompanion(MouvementsCompanion data) {
    return Mouvement(
      id: data.id.present ? data.id.value : this.id,
      enfantId: data.enfantId.present ? data.enfantId.value : this.enfantId,
      regleId: data.regleId.present ? data.regleId.value : this.regleId,
      recompenseId: data.recompenseId.present
          ? data.recompenseId.value
          : this.recompenseId,
      delta: data.delta.present ? data.delta.value : this.delta,
      note: data.note.present ? data.note.value : this.note,
      creeLe: data.creeLe.present ? data.creeLe.value : this.creeLe,
      annule: data.annule.present ? data.annule.value : this.annule,
    );
  }

  @override
  String toString() {
    return (StringBuffer('Mouvement(')
          ..write('id: $id, ')
          ..write('enfantId: $enfantId, ')
          ..write('regleId: $regleId, ')
          ..write('recompenseId: $recompenseId, ')
          ..write('delta: $delta, ')
          ..write('note: $note, ')
          ..write('creeLe: $creeLe, ')
          ..write('annule: $annule')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(
    id,
    enfantId,
    regleId,
    recompenseId,
    delta,
    note,
    creeLe,
    annule,
  );
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is Mouvement &&
          other.id == this.id &&
          other.enfantId == this.enfantId &&
          other.regleId == this.regleId &&
          other.recompenseId == this.recompenseId &&
          other.delta == this.delta &&
          other.note == this.note &&
          other.creeLe == this.creeLe &&
          other.annule == this.annule);
}

class MouvementsCompanion extends UpdateCompanion<Mouvement> {
  final Value<int> id;
  final Value<int> enfantId;
  final Value<int?> regleId;
  final Value<int?> recompenseId;
  final Value<int> delta;
  final Value<String?> note;
  final Value<DateTime> creeLe;
  final Value<bool> annule;
  const MouvementsCompanion({
    this.id = const Value.absent(),
    this.enfantId = const Value.absent(),
    this.regleId = const Value.absent(),
    this.recompenseId = const Value.absent(),
    this.delta = const Value.absent(),
    this.note = const Value.absent(),
    this.creeLe = const Value.absent(),
    this.annule = const Value.absent(),
  });
  MouvementsCompanion.insert({
    this.id = const Value.absent(),
    required int enfantId,
    this.regleId = const Value.absent(),
    this.recompenseId = const Value.absent(),
    required int delta,
    this.note = const Value.absent(),
    this.creeLe = const Value.absent(),
    this.annule = const Value.absent(),
  }) : enfantId = Value(enfantId),
       delta = Value(delta);
  static Insertable<Mouvement> custom({
    Expression<int>? id,
    Expression<int>? enfantId,
    Expression<int>? regleId,
    Expression<int>? recompenseId,
    Expression<int>? delta,
    Expression<String>? note,
    Expression<DateTime>? creeLe,
    Expression<bool>? annule,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (enfantId != null) 'enfant_id': enfantId,
      if (regleId != null) 'regle_id': regleId,
      if (recompenseId != null) 'recompense_id': recompenseId,
      if (delta != null) 'delta': delta,
      if (note != null) 'note': note,
      if (creeLe != null) 'cree_le': creeLe,
      if (annule != null) 'annule': annule,
    });
  }

  MouvementsCompanion copyWith({
    Value<int>? id,
    Value<int>? enfantId,
    Value<int?>? regleId,
    Value<int?>? recompenseId,
    Value<int>? delta,
    Value<String?>? note,
    Value<DateTime>? creeLe,
    Value<bool>? annule,
  }) {
    return MouvementsCompanion(
      id: id ?? this.id,
      enfantId: enfantId ?? this.enfantId,
      regleId: regleId ?? this.regleId,
      recompenseId: recompenseId ?? this.recompenseId,
      delta: delta ?? this.delta,
      note: note ?? this.note,
      creeLe: creeLe ?? this.creeLe,
      annule: annule ?? this.annule,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<int>(id.value);
    }
    if (enfantId.present) {
      map['enfant_id'] = Variable<int>(enfantId.value);
    }
    if (regleId.present) {
      map['regle_id'] = Variable<int>(regleId.value);
    }
    if (recompenseId.present) {
      map['recompense_id'] = Variable<int>(recompenseId.value);
    }
    if (delta.present) {
      map['delta'] = Variable<int>(delta.value);
    }
    if (note.present) {
      map['note'] = Variable<String>(note.value);
    }
    if (creeLe.present) {
      map['cree_le'] = Variable<DateTime>(creeLe.value);
    }
    if (annule.present) {
      map['annule'] = Variable<bool>(annule.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('MouvementsCompanion(')
          ..write('id: $id, ')
          ..write('enfantId: $enfantId, ')
          ..write('regleId: $regleId, ')
          ..write('recompenseId: $recompenseId, ')
          ..write('delta: $delta, ')
          ..write('note: $note, ')
          ..write('creeLe: $creeLe, ')
          ..write('annule: $annule')
          ..write(')'))
        .toString();
  }
}

class $ConfigTable extends Config with TableInfo<$ConfigTable, ConfigData> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $ConfigTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _cleMeta = const VerificationMeta('cle');
  @override
  late final GeneratedColumn<String> cle = GeneratedColumn<String>(
    'cle',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _valeurMeta = const VerificationMeta('valeur');
  @override
  late final GeneratedColumn<String> valeur = GeneratedColumn<String>(
    'valeur',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  @override
  List<GeneratedColumn> get $columns => [cle, valeur];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'config';
  @override
  VerificationContext validateIntegrity(
    Insertable<ConfigData> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('cle')) {
      context.handle(
        _cleMeta,
        cle.isAcceptableOrUnknown(data['cle']!, _cleMeta),
      );
    } else if (isInserting) {
      context.missing(_cleMeta);
    }
    if (data.containsKey('valeur')) {
      context.handle(
        _valeurMeta,
        valeur.isAcceptableOrUnknown(data['valeur']!, _valeurMeta),
      );
    } else if (isInserting) {
      context.missing(_valeurMeta);
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {cle};
  @override
  ConfigData map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return ConfigData(
      cle: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}cle'],
      )!,
      valeur: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}valeur'],
      )!,
    );
  }

  @override
  $ConfigTable createAlias(String alias) {
    return $ConfigTable(attachedDatabase, alias);
  }
}

class ConfigData extends DataClass implements Insertable<ConfigData> {
  final String cle;
  final String valeur;
  const ConfigData({required this.cle, required this.valeur});
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['cle'] = Variable<String>(cle);
    map['valeur'] = Variable<String>(valeur);
    return map;
  }

  ConfigCompanion toCompanion(bool nullToAbsent) {
    return ConfigCompanion(cle: Value(cle), valeur: Value(valeur));
  }

  factory ConfigData.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return ConfigData(
      cle: serializer.fromJson<String>(json['cle']),
      valeur: serializer.fromJson<String>(json['valeur']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'cle': serializer.toJson<String>(cle),
      'valeur': serializer.toJson<String>(valeur),
    };
  }

  ConfigData copyWith({String? cle, String? valeur}) =>
      ConfigData(cle: cle ?? this.cle, valeur: valeur ?? this.valeur);
  ConfigData copyWithCompanion(ConfigCompanion data) {
    return ConfigData(
      cle: data.cle.present ? data.cle.value : this.cle,
      valeur: data.valeur.present ? data.valeur.value : this.valeur,
    );
  }

  @override
  String toString() {
    return (StringBuffer('ConfigData(')
          ..write('cle: $cle, ')
          ..write('valeur: $valeur')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(cle, valeur);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is ConfigData &&
          other.cle == this.cle &&
          other.valeur == this.valeur);
}

class ConfigCompanion extends UpdateCompanion<ConfigData> {
  final Value<String> cle;
  final Value<String> valeur;
  final Value<int> rowid;
  const ConfigCompanion({
    this.cle = const Value.absent(),
    this.valeur = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  ConfigCompanion.insert({
    required String cle,
    required String valeur,
    this.rowid = const Value.absent(),
  }) : cle = Value(cle),
       valeur = Value(valeur);
  static Insertable<ConfigData> custom({
    Expression<String>? cle,
    Expression<String>? valeur,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (cle != null) 'cle': cle,
      if (valeur != null) 'valeur': valeur,
      if (rowid != null) 'rowid': rowid,
    });
  }

  ConfigCompanion copyWith({
    Value<String>? cle,
    Value<String>? valeur,
    Value<int>? rowid,
  }) {
    return ConfigCompanion(
      cle: cle ?? this.cle,
      valeur: valeur ?? this.valeur,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (cle.present) {
      map['cle'] = Variable<String>(cle.value);
    }
    if (valeur.present) {
      map['valeur'] = Variable<String>(valeur.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('ConfigCompanion(')
          ..write('cle: $cle, ')
          ..write('valeur: $valeur, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

abstract class _$AppDatabase extends GeneratedDatabase {
  _$AppDatabase(QueryExecutor e) : super(e);
  $AppDatabaseManager get managers => $AppDatabaseManager(this);
  late final $EnfantsTable enfants = $EnfantsTable(this);
  late final $ReglesTable regles = $ReglesTable(this);
  late final $RecompensesTable recompenses = $RecompensesTable(this);
  late final $MouvementsTable mouvements = $MouvementsTable(this);
  late final $ConfigTable config = $ConfigTable(this);
  @override
  Iterable<TableInfo<Table, Object?>> get allTables =>
      allSchemaEntities.whereType<TableInfo<Table, Object?>>();
  @override
  List<DatabaseSchemaEntity> get allSchemaEntities => [
    enfants,
    regles,
    recompenses,
    mouvements,
    config,
  ];
}

typedef $$EnfantsTableCreateCompanionBuilder =
    EnfantsCompanion Function({
      Value<int> id,
      required String prenom,
      Value<String?> dateNaissance,
      Value<int> score,
      Value<String> couleur,
      Value<int> ordre,
    });
typedef $$EnfantsTableUpdateCompanionBuilder =
    EnfantsCompanion Function({
      Value<int> id,
      Value<String> prenom,
      Value<String?> dateNaissance,
      Value<int> score,
      Value<String> couleur,
      Value<int> ordre,
    });

final class $$EnfantsTableReferences
    extends BaseReferences<_$AppDatabase, $EnfantsTable, Enfant> {
  $$EnfantsTableReferences(super.$_db, super.$_table, super.$_typedResult);

  static MultiTypedResultKey<$MouvementsTable, List<Mouvement>>
  _mouvementsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
    db.mouvements,
    aliasName: 'enfants__id__mouvements__enfant_id',
  );

  $$MouvementsTableProcessedTableManager get mouvementsRefs {
    final manager = $$MouvementsTableTableManager(
      $_db,
      $_db.mouvements,
    ).filter((f) => f.enfantId.id.sqlEquals($_itemColumn<int>('id')!));

    final cache = $_typedResult.readTableOrNull(_mouvementsRefsTable($_db));
    return ProcessedTableManager(
      manager.$state.copyWith(prefetchedData: cache),
    );
  }
}

class $$EnfantsTableFilterComposer
    extends Composer<_$AppDatabase, $EnfantsTable> {
  $$EnfantsTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<int> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<String> get prenom => $composableBuilder(
    column: $table.prenom,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<String> get dateNaissance => $composableBuilder(
    column: $table.dateNaissance,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<int> get score => $composableBuilder(
    column: $table.score,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<String> get couleur => $composableBuilder(
    column: $table.couleur,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<int> get ordre => $composableBuilder(
    column: $table.ordre,
    builder: (column) => ColumnFilters(column),
  );

  Expression<bool> mouvementsRefs(
    Expression<bool> Function($$MouvementsTableFilterComposer f) f,
  ) {
    final $$MouvementsTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.id,
      referencedTable: $db.mouvements,
      getReferencedColumn: (t) => t.enfantId,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$MouvementsTableFilterComposer(
            $db: $db,
            $table: $db.mouvements,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $$EnfantsTableOrderingComposer
    extends Composer<_$AppDatabase, $EnfantsTable> {
  $$EnfantsTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<int> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<String> get prenom => $composableBuilder(
    column: $table.prenom,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<String> get dateNaissance => $composableBuilder(
    column: $table.dateNaissance,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<int> get score => $composableBuilder(
    column: $table.score,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<String> get couleur => $composableBuilder(
    column: $table.couleur,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<int> get ordre => $composableBuilder(
    column: $table.ordre,
    builder: (column) => ColumnOrderings(column),
  );
}

class $$EnfantsTableAnnotationComposer
    extends Composer<_$AppDatabase, $EnfantsTable> {
  $$EnfantsTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<int> get id =>
      $composableBuilder(column: $table.id, builder: (column) => column);

  GeneratedColumn<String> get prenom =>
      $composableBuilder(column: $table.prenom, builder: (column) => column);

  GeneratedColumn<String> get dateNaissance => $composableBuilder(
    column: $table.dateNaissance,
    builder: (column) => column,
  );

  GeneratedColumn<int> get score =>
      $composableBuilder(column: $table.score, builder: (column) => column);

  GeneratedColumn<String> get couleur =>
      $composableBuilder(column: $table.couleur, builder: (column) => column);

  GeneratedColumn<int> get ordre =>
      $composableBuilder(column: $table.ordre, builder: (column) => column);

  Expression<T> mouvementsRefs<T extends Object>(
    Expression<T> Function($$MouvementsTableAnnotationComposer a) f,
  ) {
    final $$MouvementsTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.id,
      referencedTable: $db.mouvements,
      getReferencedColumn: (t) => t.enfantId,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$MouvementsTableAnnotationComposer(
            $db: $db,
            $table: $db.mouvements,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $$EnfantsTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $EnfantsTable,
          Enfant,
          $$EnfantsTableFilterComposer,
          $$EnfantsTableOrderingComposer,
          $$EnfantsTableAnnotationComposer,
          $$EnfantsTableCreateCompanionBuilder,
          $$EnfantsTableUpdateCompanionBuilder,
          (Enfant, $$EnfantsTableReferences),
          Enfant,
          PrefetchHooks Function({bool mouvementsRefs})
        > {
  $$EnfantsTableTableManager(_$AppDatabase db, $EnfantsTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$EnfantsTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$EnfantsTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$EnfantsTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                Value<String> prenom = const Value.absent(),
                Value<String?> dateNaissance = const Value.absent(),
                Value<int> score = const Value.absent(),
                Value<String> couleur = const Value.absent(),
                Value<int> ordre = const Value.absent(),
              }) => EnfantsCompanion(
                id: id,
                prenom: prenom,
                dateNaissance: dateNaissance,
                score: score,
                couleur: couleur,
                ordre: ordre,
              ),
          createCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                required String prenom,
                Value<String?> dateNaissance = const Value.absent(),
                Value<int> score = const Value.absent(),
                Value<String> couleur = const Value.absent(),
                Value<int> ordre = const Value.absent(),
              }) => EnfantsCompanion.insert(
                id: id,
                prenom: prenom,
                dateNaissance: dateNaissance,
                score: score,
                couleur: couleur,
                ordre: ordre,
              ),
          withReferenceMapper: (p0) => p0
              .map(
                (e) => (
                  e.readTable(table),
                  $$EnfantsTableReferences(db, table, e),
                ),
              )
              .toList(),
          prefetchHooksCallback: ({mouvementsRefs = false}) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [if (mouvementsRefs) db.mouvements],
              addJoins: null,
              getPrefetchedDataCallback: (items) async {
                return [
                  if (mouvementsRefs)
                    await $_getPrefetchedData<Enfant, $EnfantsTable, Mouvement>(
                      currentTable: table,
                      referencedTable: $$EnfantsTableReferences
                          ._mouvementsRefsTable(db),
                      managerFromTypedResult: (p0) => $$EnfantsTableReferences(
                        db,
                        table,
                        p0,
                      ).mouvementsRefs,
                      referencedItemsForCurrentItem: (item, referencedItems) =>
                          referencedItems.where((e) => e.enfantId == item.id),
                      typedResults: items,
                    ),
                ];
              },
            );
          },
        ),
      );
}

typedef $$EnfantsTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $EnfantsTable,
      Enfant,
      $$EnfantsTableFilterComposer,
      $$EnfantsTableOrderingComposer,
      $$EnfantsTableAnnotationComposer,
      $$EnfantsTableCreateCompanionBuilder,
      $$EnfantsTableUpdateCompanionBuilder,
      (Enfant, $$EnfantsTableReferences),
      Enfant,
      PrefetchHooks Function({bool mouvementsRefs})
    >;
typedef $$ReglesTableCreateCompanionBuilder =
    ReglesCompanion Function({
      Value<int> id,
      required String libelle,
      required int points,
      Value<String> icone,
      Value<bool> actif,
      Value<int> ordre,
      Value<String> famille,
      Value<int> familleOrdre,
    });
typedef $$ReglesTableUpdateCompanionBuilder =
    ReglesCompanion Function({
      Value<int> id,
      Value<String> libelle,
      Value<int> points,
      Value<String> icone,
      Value<bool> actif,
      Value<int> ordre,
      Value<String> famille,
      Value<int> familleOrdre,
    });

final class $$ReglesTableReferences
    extends BaseReferences<_$AppDatabase, $ReglesTable, Regle> {
  $$ReglesTableReferences(super.$_db, super.$_table, super.$_typedResult);

  static MultiTypedResultKey<$MouvementsTable, List<Mouvement>>
  _mouvementsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
    db.mouvements,
    aliasName: 'regles__id__mouvements__regle_id',
  );

  $$MouvementsTableProcessedTableManager get mouvementsRefs {
    final manager = $$MouvementsTableTableManager(
      $_db,
      $_db.mouvements,
    ).filter((f) => f.regleId.id.sqlEquals($_itemColumn<int>('id')!));

    final cache = $_typedResult.readTableOrNull(_mouvementsRefsTable($_db));
    return ProcessedTableManager(
      manager.$state.copyWith(prefetchedData: cache),
    );
  }
}

class $$ReglesTableFilterComposer
    extends Composer<_$AppDatabase, $ReglesTable> {
  $$ReglesTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<int> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<String> get libelle => $composableBuilder(
    column: $table.libelle,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<int> get points => $composableBuilder(
    column: $table.points,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<String> get icone => $composableBuilder(
    column: $table.icone,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<bool> get actif => $composableBuilder(
    column: $table.actif,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<int> get ordre => $composableBuilder(
    column: $table.ordre,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<String> get famille => $composableBuilder(
    column: $table.famille,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<int> get familleOrdre => $composableBuilder(
    column: $table.familleOrdre,
    builder: (column) => ColumnFilters(column),
  );

  Expression<bool> mouvementsRefs(
    Expression<bool> Function($$MouvementsTableFilterComposer f) f,
  ) {
    final $$MouvementsTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.id,
      referencedTable: $db.mouvements,
      getReferencedColumn: (t) => t.regleId,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$MouvementsTableFilterComposer(
            $db: $db,
            $table: $db.mouvements,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $$ReglesTableOrderingComposer
    extends Composer<_$AppDatabase, $ReglesTable> {
  $$ReglesTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<int> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<String> get libelle => $composableBuilder(
    column: $table.libelle,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<int> get points => $composableBuilder(
    column: $table.points,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<String> get icone => $composableBuilder(
    column: $table.icone,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<bool> get actif => $composableBuilder(
    column: $table.actif,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<int> get ordre => $composableBuilder(
    column: $table.ordre,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<String> get famille => $composableBuilder(
    column: $table.famille,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<int> get familleOrdre => $composableBuilder(
    column: $table.familleOrdre,
    builder: (column) => ColumnOrderings(column),
  );
}

class $$ReglesTableAnnotationComposer
    extends Composer<_$AppDatabase, $ReglesTable> {
  $$ReglesTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<int> get id =>
      $composableBuilder(column: $table.id, builder: (column) => column);

  GeneratedColumn<String> get libelle =>
      $composableBuilder(column: $table.libelle, builder: (column) => column);

  GeneratedColumn<int> get points =>
      $composableBuilder(column: $table.points, builder: (column) => column);

  GeneratedColumn<String> get icone =>
      $composableBuilder(column: $table.icone, builder: (column) => column);

  GeneratedColumn<bool> get actif =>
      $composableBuilder(column: $table.actif, builder: (column) => column);

  GeneratedColumn<int> get ordre =>
      $composableBuilder(column: $table.ordre, builder: (column) => column);

  GeneratedColumn<String> get famille =>
      $composableBuilder(column: $table.famille, builder: (column) => column);

  GeneratedColumn<int> get familleOrdre => $composableBuilder(
    column: $table.familleOrdre,
    builder: (column) => column,
  );

  Expression<T> mouvementsRefs<T extends Object>(
    Expression<T> Function($$MouvementsTableAnnotationComposer a) f,
  ) {
    final $$MouvementsTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.id,
      referencedTable: $db.mouvements,
      getReferencedColumn: (t) => t.regleId,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$MouvementsTableAnnotationComposer(
            $db: $db,
            $table: $db.mouvements,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $$ReglesTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $ReglesTable,
          Regle,
          $$ReglesTableFilterComposer,
          $$ReglesTableOrderingComposer,
          $$ReglesTableAnnotationComposer,
          $$ReglesTableCreateCompanionBuilder,
          $$ReglesTableUpdateCompanionBuilder,
          (Regle, $$ReglesTableReferences),
          Regle,
          PrefetchHooks Function({bool mouvementsRefs})
        > {
  $$ReglesTableTableManager(_$AppDatabase db, $ReglesTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$ReglesTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$ReglesTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$ReglesTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                Value<String> libelle = const Value.absent(),
                Value<int> points = const Value.absent(),
                Value<String> icone = const Value.absent(),
                Value<bool> actif = const Value.absent(),
                Value<int> ordre = const Value.absent(),
                Value<String> famille = const Value.absent(),
                Value<int> familleOrdre = const Value.absent(),
              }) => ReglesCompanion(
                id: id,
                libelle: libelle,
                points: points,
                icone: icone,
                actif: actif,
                ordre: ordre,
                famille: famille,
                familleOrdre: familleOrdre,
              ),
          createCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                required String libelle,
                required int points,
                Value<String> icone = const Value.absent(),
                Value<bool> actif = const Value.absent(),
                Value<int> ordre = const Value.absent(),
                Value<String> famille = const Value.absent(),
                Value<int> familleOrdre = const Value.absent(),
              }) => ReglesCompanion.insert(
                id: id,
                libelle: libelle,
                points: points,
                icone: icone,
                actif: actif,
                ordre: ordre,
                famille: famille,
                familleOrdre: familleOrdre,
              ),
          withReferenceMapper: (p0) => p0
              .map(
                (e) =>
                    (e.readTable(table), $$ReglesTableReferences(db, table, e)),
              )
              .toList(),
          prefetchHooksCallback: ({mouvementsRefs = false}) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [if (mouvementsRefs) db.mouvements],
              addJoins: null,
              getPrefetchedDataCallback: (items) async {
                return [
                  if (mouvementsRefs)
                    await $_getPrefetchedData<Regle, $ReglesTable, Mouvement>(
                      currentTable: table,
                      referencedTable: $$ReglesTableReferences
                          ._mouvementsRefsTable(db),
                      managerFromTypedResult: (p0) =>
                          $$ReglesTableReferences(db, table, p0).mouvementsRefs,
                      referencedItemsForCurrentItem: (item, referencedItems) =>
                          referencedItems.where((e) => e.regleId == item.id),
                      typedResults: items,
                    ),
                ];
              },
            );
          },
        ),
      );
}

typedef $$ReglesTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $ReglesTable,
      Regle,
      $$ReglesTableFilterComposer,
      $$ReglesTableOrderingComposer,
      $$ReglesTableAnnotationComposer,
      $$ReglesTableCreateCompanionBuilder,
      $$ReglesTableUpdateCompanionBuilder,
      (Regle, $$ReglesTableReferences),
      Regle,
      PrefetchHooks Function({bool mouvementsRefs})
    >;
typedef $$RecompensesTableCreateCompanionBuilder =
    RecompensesCompanion Function({
      Value<int> id,
      required String libelle,
      required int coutPoints,
      Value<String> icone,
      Value<bool> actif,
      Value<int> ordre,
    });
typedef $$RecompensesTableUpdateCompanionBuilder =
    RecompensesCompanion Function({
      Value<int> id,
      Value<String> libelle,
      Value<int> coutPoints,
      Value<String> icone,
      Value<bool> actif,
      Value<int> ordre,
    });

final class $$RecompensesTableReferences
    extends BaseReferences<_$AppDatabase, $RecompensesTable, Recompense> {
  $$RecompensesTableReferences(super.$_db, super.$_table, super.$_typedResult);

  static MultiTypedResultKey<$MouvementsTable, List<Mouvement>>
  _mouvementsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
    db.mouvements,
    aliasName: 'recompenses__id__mouvements__recompense_id',
  );

  $$MouvementsTableProcessedTableManager get mouvementsRefs {
    final manager = $$MouvementsTableTableManager(
      $_db,
      $_db.mouvements,
    ).filter((f) => f.recompenseId.id.sqlEquals($_itemColumn<int>('id')!));

    final cache = $_typedResult.readTableOrNull(_mouvementsRefsTable($_db));
    return ProcessedTableManager(
      manager.$state.copyWith(prefetchedData: cache),
    );
  }
}

class $$RecompensesTableFilterComposer
    extends Composer<_$AppDatabase, $RecompensesTable> {
  $$RecompensesTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<int> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<String> get libelle => $composableBuilder(
    column: $table.libelle,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<int> get coutPoints => $composableBuilder(
    column: $table.coutPoints,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<String> get icone => $composableBuilder(
    column: $table.icone,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<bool> get actif => $composableBuilder(
    column: $table.actif,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<int> get ordre => $composableBuilder(
    column: $table.ordre,
    builder: (column) => ColumnFilters(column),
  );

  Expression<bool> mouvementsRefs(
    Expression<bool> Function($$MouvementsTableFilterComposer f) f,
  ) {
    final $$MouvementsTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.id,
      referencedTable: $db.mouvements,
      getReferencedColumn: (t) => t.recompenseId,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$MouvementsTableFilterComposer(
            $db: $db,
            $table: $db.mouvements,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $$RecompensesTableOrderingComposer
    extends Composer<_$AppDatabase, $RecompensesTable> {
  $$RecompensesTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<int> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<String> get libelle => $composableBuilder(
    column: $table.libelle,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<int> get coutPoints => $composableBuilder(
    column: $table.coutPoints,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<String> get icone => $composableBuilder(
    column: $table.icone,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<bool> get actif => $composableBuilder(
    column: $table.actif,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<int> get ordre => $composableBuilder(
    column: $table.ordre,
    builder: (column) => ColumnOrderings(column),
  );
}

class $$RecompensesTableAnnotationComposer
    extends Composer<_$AppDatabase, $RecompensesTable> {
  $$RecompensesTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<int> get id =>
      $composableBuilder(column: $table.id, builder: (column) => column);

  GeneratedColumn<String> get libelle =>
      $composableBuilder(column: $table.libelle, builder: (column) => column);

  GeneratedColumn<int> get coutPoints => $composableBuilder(
    column: $table.coutPoints,
    builder: (column) => column,
  );

  GeneratedColumn<String> get icone =>
      $composableBuilder(column: $table.icone, builder: (column) => column);

  GeneratedColumn<bool> get actif =>
      $composableBuilder(column: $table.actif, builder: (column) => column);

  GeneratedColumn<int> get ordre =>
      $composableBuilder(column: $table.ordre, builder: (column) => column);

  Expression<T> mouvementsRefs<T extends Object>(
    Expression<T> Function($$MouvementsTableAnnotationComposer a) f,
  ) {
    final $$MouvementsTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.id,
      referencedTable: $db.mouvements,
      getReferencedColumn: (t) => t.recompenseId,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$MouvementsTableAnnotationComposer(
            $db: $db,
            $table: $db.mouvements,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $$RecompensesTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $RecompensesTable,
          Recompense,
          $$RecompensesTableFilterComposer,
          $$RecompensesTableOrderingComposer,
          $$RecompensesTableAnnotationComposer,
          $$RecompensesTableCreateCompanionBuilder,
          $$RecompensesTableUpdateCompanionBuilder,
          (Recompense, $$RecompensesTableReferences),
          Recompense,
          PrefetchHooks Function({bool mouvementsRefs})
        > {
  $$RecompensesTableTableManager(_$AppDatabase db, $RecompensesTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$RecompensesTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$RecompensesTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$RecompensesTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                Value<String> libelle = const Value.absent(),
                Value<int> coutPoints = const Value.absent(),
                Value<String> icone = const Value.absent(),
                Value<bool> actif = const Value.absent(),
                Value<int> ordre = const Value.absent(),
              }) => RecompensesCompanion(
                id: id,
                libelle: libelle,
                coutPoints: coutPoints,
                icone: icone,
                actif: actif,
                ordre: ordre,
              ),
          createCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                required String libelle,
                required int coutPoints,
                Value<String> icone = const Value.absent(),
                Value<bool> actif = const Value.absent(),
                Value<int> ordre = const Value.absent(),
              }) => RecompensesCompanion.insert(
                id: id,
                libelle: libelle,
                coutPoints: coutPoints,
                icone: icone,
                actif: actif,
                ordre: ordre,
              ),
          withReferenceMapper: (p0) => p0
              .map(
                (e) => (
                  e.readTable(table),
                  $$RecompensesTableReferences(db, table, e),
                ),
              )
              .toList(),
          prefetchHooksCallback: ({mouvementsRefs = false}) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [if (mouvementsRefs) db.mouvements],
              addJoins: null,
              getPrefetchedDataCallback: (items) async {
                return [
                  if (mouvementsRefs)
                    await $_getPrefetchedData<
                      Recompense,
                      $RecompensesTable,
                      Mouvement
                    >(
                      currentTable: table,
                      referencedTable: $$RecompensesTableReferences
                          ._mouvementsRefsTable(db),
                      managerFromTypedResult: (p0) =>
                          $$RecompensesTableReferences(
                            db,
                            table,
                            p0,
                          ).mouvementsRefs,
                      referencedItemsForCurrentItem: (item, referencedItems) =>
                          referencedItems.where(
                            (e) => e.recompenseId == item.id,
                          ),
                      typedResults: items,
                    ),
                ];
              },
            );
          },
        ),
      );
}

typedef $$RecompensesTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $RecompensesTable,
      Recompense,
      $$RecompensesTableFilterComposer,
      $$RecompensesTableOrderingComposer,
      $$RecompensesTableAnnotationComposer,
      $$RecompensesTableCreateCompanionBuilder,
      $$RecompensesTableUpdateCompanionBuilder,
      (Recompense, $$RecompensesTableReferences),
      Recompense,
      PrefetchHooks Function({bool mouvementsRefs})
    >;
typedef $$MouvementsTableCreateCompanionBuilder =
    MouvementsCompanion Function({
      Value<int> id,
      required int enfantId,
      Value<int?> regleId,
      Value<int?> recompenseId,
      required int delta,
      Value<String?> note,
      Value<DateTime> creeLe,
      Value<bool> annule,
    });
typedef $$MouvementsTableUpdateCompanionBuilder =
    MouvementsCompanion Function({
      Value<int> id,
      Value<int> enfantId,
      Value<int?> regleId,
      Value<int?> recompenseId,
      Value<int> delta,
      Value<String?> note,
      Value<DateTime> creeLe,
      Value<bool> annule,
    });

final class $$MouvementsTableReferences
    extends BaseReferences<_$AppDatabase, $MouvementsTable, Mouvement> {
  $$MouvementsTableReferences(super.$_db, super.$_table, super.$_typedResult);

  static $EnfantsTable _enfantIdTable(_$AppDatabase db) =>
      db.enfants.createAlias('mouvements__enfant_id__enfants__id');

  $$EnfantsTableProcessedTableManager get enfantId {
    final $_column = $_itemColumn<int>('enfant_id')!;

    final manager = $$EnfantsTableTableManager(
      $_db,
      $_db.enfants,
    ).filter((f) => f.id.sqlEquals($_column));
    final item = $_typedResult.readTableOrNull(_enfantIdTable($_db));
    if (item == null) return manager;
    return ProcessedTableManager(
      manager.$state.copyWith(prefetchedData: [item]),
    );
  }

  static $ReglesTable _regleIdTable(_$AppDatabase db) =>
      db.regles.createAlias('mouvements__regle_id__regles__id');

  $$ReglesTableProcessedTableManager? get regleId {
    final $_column = $_itemColumn<int>('regle_id');
    if ($_column == null) return null;
    final manager = $$ReglesTableTableManager(
      $_db,
      $_db.regles,
    ).filter((f) => f.id.sqlEquals($_column));
    final item = $_typedResult.readTableOrNull(_regleIdTable($_db));
    if (item == null) return manager;
    return ProcessedTableManager(
      manager.$state.copyWith(prefetchedData: [item]),
    );
  }

  static $RecompensesTable _recompenseIdTable(_$AppDatabase db) =>
      db.recompenses.createAlias('mouvements__recompense_id__recompenses__id');

  $$RecompensesTableProcessedTableManager? get recompenseId {
    final $_column = $_itemColumn<int>('recompense_id');
    if ($_column == null) return null;
    final manager = $$RecompensesTableTableManager(
      $_db,
      $_db.recompenses,
    ).filter((f) => f.id.sqlEquals($_column));
    final item = $_typedResult.readTableOrNull(_recompenseIdTable($_db));
    if (item == null) return manager;
    return ProcessedTableManager(
      manager.$state.copyWith(prefetchedData: [item]),
    );
  }
}

class $$MouvementsTableFilterComposer
    extends Composer<_$AppDatabase, $MouvementsTable> {
  $$MouvementsTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<int> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<int> get delta => $composableBuilder(
    column: $table.delta,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<String> get note => $composableBuilder(
    column: $table.note,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<DateTime> get creeLe => $composableBuilder(
    column: $table.creeLe,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<bool> get annule => $composableBuilder(
    column: $table.annule,
    builder: (column) => ColumnFilters(column),
  );

  $$EnfantsTableFilterComposer get enfantId {
    final $$EnfantsTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.enfantId,
      referencedTable: $db.enfants,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$EnfantsTableFilterComposer(
            $db: $db,
            $table: $db.enfants,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }

  $$ReglesTableFilterComposer get regleId {
    final $$ReglesTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.regleId,
      referencedTable: $db.regles,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$ReglesTableFilterComposer(
            $db: $db,
            $table: $db.regles,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }

  $$RecompensesTableFilterComposer get recompenseId {
    final $$RecompensesTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.recompenseId,
      referencedTable: $db.recompenses,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$RecompensesTableFilterComposer(
            $db: $db,
            $table: $db.recompenses,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }
}

class $$MouvementsTableOrderingComposer
    extends Composer<_$AppDatabase, $MouvementsTable> {
  $$MouvementsTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<int> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<int> get delta => $composableBuilder(
    column: $table.delta,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<String> get note => $composableBuilder(
    column: $table.note,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<DateTime> get creeLe => $composableBuilder(
    column: $table.creeLe,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<bool> get annule => $composableBuilder(
    column: $table.annule,
    builder: (column) => ColumnOrderings(column),
  );

  $$EnfantsTableOrderingComposer get enfantId {
    final $$EnfantsTableOrderingComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.enfantId,
      referencedTable: $db.enfants,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$EnfantsTableOrderingComposer(
            $db: $db,
            $table: $db.enfants,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }

  $$ReglesTableOrderingComposer get regleId {
    final $$ReglesTableOrderingComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.regleId,
      referencedTable: $db.regles,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$ReglesTableOrderingComposer(
            $db: $db,
            $table: $db.regles,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }

  $$RecompensesTableOrderingComposer get recompenseId {
    final $$RecompensesTableOrderingComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.recompenseId,
      referencedTable: $db.recompenses,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$RecompensesTableOrderingComposer(
            $db: $db,
            $table: $db.recompenses,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }
}

class $$MouvementsTableAnnotationComposer
    extends Composer<_$AppDatabase, $MouvementsTable> {
  $$MouvementsTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<int> get id =>
      $composableBuilder(column: $table.id, builder: (column) => column);

  GeneratedColumn<int> get delta =>
      $composableBuilder(column: $table.delta, builder: (column) => column);

  GeneratedColumn<String> get note =>
      $composableBuilder(column: $table.note, builder: (column) => column);

  GeneratedColumn<DateTime> get creeLe =>
      $composableBuilder(column: $table.creeLe, builder: (column) => column);

  GeneratedColumn<bool> get annule =>
      $composableBuilder(column: $table.annule, builder: (column) => column);

  $$EnfantsTableAnnotationComposer get enfantId {
    final $$EnfantsTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.enfantId,
      referencedTable: $db.enfants,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$EnfantsTableAnnotationComposer(
            $db: $db,
            $table: $db.enfants,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }

  $$ReglesTableAnnotationComposer get regleId {
    final $$ReglesTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.regleId,
      referencedTable: $db.regles,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$ReglesTableAnnotationComposer(
            $db: $db,
            $table: $db.regles,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }

  $$RecompensesTableAnnotationComposer get recompenseId {
    final $$RecompensesTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.recompenseId,
      referencedTable: $db.recompenses,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$RecompensesTableAnnotationComposer(
            $db: $db,
            $table: $db.recompenses,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }
}

class $$MouvementsTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $MouvementsTable,
          Mouvement,
          $$MouvementsTableFilterComposer,
          $$MouvementsTableOrderingComposer,
          $$MouvementsTableAnnotationComposer,
          $$MouvementsTableCreateCompanionBuilder,
          $$MouvementsTableUpdateCompanionBuilder,
          (Mouvement, $$MouvementsTableReferences),
          Mouvement,
          PrefetchHooks Function({
            bool enfantId,
            bool regleId,
            bool recompenseId,
          })
        > {
  $$MouvementsTableTableManager(_$AppDatabase db, $MouvementsTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$MouvementsTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$MouvementsTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$MouvementsTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                Value<int> enfantId = const Value.absent(),
                Value<int?> regleId = const Value.absent(),
                Value<int?> recompenseId = const Value.absent(),
                Value<int> delta = const Value.absent(),
                Value<String?> note = const Value.absent(),
                Value<DateTime> creeLe = const Value.absent(),
                Value<bool> annule = const Value.absent(),
              }) => MouvementsCompanion(
                id: id,
                enfantId: enfantId,
                regleId: regleId,
                recompenseId: recompenseId,
                delta: delta,
                note: note,
                creeLe: creeLe,
                annule: annule,
              ),
          createCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                required int enfantId,
                Value<int?> regleId = const Value.absent(),
                Value<int?> recompenseId = const Value.absent(),
                required int delta,
                Value<String?> note = const Value.absent(),
                Value<DateTime> creeLe = const Value.absent(),
                Value<bool> annule = const Value.absent(),
              }) => MouvementsCompanion.insert(
                id: id,
                enfantId: enfantId,
                regleId: regleId,
                recompenseId: recompenseId,
                delta: delta,
                note: note,
                creeLe: creeLe,
                annule: annule,
              ),
          withReferenceMapper: (p0) => p0
              .map(
                (e) => (
                  e.readTable(table),
                  $$MouvementsTableReferences(db, table, e),
                ),
              )
              .toList(),
          prefetchHooksCallback:
              ({enfantId = false, regleId = false, recompenseId = false}) {
                return PrefetchHooks(
                  db: db,
                  explicitlyWatchedTables: [],
                  addJoins:
                      <
                        T extends TableManagerState<
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic
                        >
                      >(state) {
                        if (enfantId) {
                          state =
                              state.withJoin(
                                    currentTable: table,
                                    currentColumn: table.enfantId,
                                    referencedTable: $$MouvementsTableReferences
                                        ._enfantIdTable(db),
                                    referencedColumn:
                                        $$MouvementsTableReferences
                                            ._enfantIdTable(db)
                                            .id,
                                  )
                                  as T;
                        }
                        if (regleId) {
                          state =
                              state.withJoin(
                                    currentTable: table,
                                    currentColumn: table.regleId,
                                    referencedTable: $$MouvementsTableReferences
                                        ._regleIdTable(db),
                                    referencedColumn:
                                        $$MouvementsTableReferences
                                            ._regleIdTable(db)
                                            .id,
                                  )
                                  as T;
                        }
                        if (recompenseId) {
                          state =
                              state.withJoin(
                                    currentTable: table,
                                    currentColumn: table.recompenseId,
                                    referencedTable: $$MouvementsTableReferences
                                        ._recompenseIdTable(db),
                                    referencedColumn:
                                        $$MouvementsTableReferences
                                            ._recompenseIdTable(db)
                                            .id,
                                  )
                                  as T;
                        }

                        return state;
                      },
                  getPrefetchedDataCallback: (items) async {
                    return [];
                  },
                );
              },
        ),
      );
}

typedef $$MouvementsTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $MouvementsTable,
      Mouvement,
      $$MouvementsTableFilterComposer,
      $$MouvementsTableOrderingComposer,
      $$MouvementsTableAnnotationComposer,
      $$MouvementsTableCreateCompanionBuilder,
      $$MouvementsTableUpdateCompanionBuilder,
      (Mouvement, $$MouvementsTableReferences),
      Mouvement,
      PrefetchHooks Function({bool enfantId, bool regleId, bool recompenseId})
    >;
typedef $$ConfigTableCreateCompanionBuilder =
    ConfigCompanion Function({
      required String cle,
      required String valeur,
      Value<int> rowid,
    });
typedef $$ConfigTableUpdateCompanionBuilder =
    ConfigCompanion Function({
      Value<String> cle,
      Value<String> valeur,
      Value<int> rowid,
    });

class $$ConfigTableFilterComposer
    extends Composer<_$AppDatabase, $ConfigTable> {
  $$ConfigTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get cle => $composableBuilder(
    column: $table.cle,
    builder: (column) => ColumnFilters(column),
  );

  ColumnFilters<String> get valeur => $composableBuilder(
    column: $table.valeur,
    builder: (column) => ColumnFilters(column),
  );
}

class $$ConfigTableOrderingComposer
    extends Composer<_$AppDatabase, $ConfigTable> {
  $$ConfigTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get cle => $composableBuilder(
    column: $table.cle,
    builder: (column) => ColumnOrderings(column),
  );

  ColumnOrderings<String> get valeur => $composableBuilder(
    column: $table.valeur,
    builder: (column) => ColumnOrderings(column),
  );
}

class $$ConfigTableAnnotationComposer
    extends Composer<_$AppDatabase, $ConfigTable> {
  $$ConfigTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get cle =>
      $composableBuilder(column: $table.cle, builder: (column) => column);

  GeneratedColumn<String> get valeur =>
      $composableBuilder(column: $table.valeur, builder: (column) => column);
}

class $$ConfigTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $ConfigTable,
          ConfigData,
          $$ConfigTableFilterComposer,
          $$ConfigTableOrderingComposer,
          $$ConfigTableAnnotationComposer,
          $$ConfigTableCreateCompanionBuilder,
          $$ConfigTableUpdateCompanionBuilder,
          (ConfigData, BaseReferences<_$AppDatabase, $ConfigTable, ConfigData>),
          ConfigData,
          PrefetchHooks Function()
        > {
  $$ConfigTableTableManager(_$AppDatabase db, $ConfigTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$ConfigTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$ConfigTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$ConfigTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> cle = const Value.absent(),
                Value<String> valeur = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => ConfigCompanion(cle: cle, valeur: valeur, rowid: rowid),
          createCompanionCallback:
              ({
                required String cle,
                required String valeur,
                Value<int> rowid = const Value.absent(),
              }) => ConfigCompanion.insert(
                cle: cle,
                valeur: valeur,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$ConfigTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $ConfigTable,
      ConfigData,
      $$ConfigTableFilterComposer,
      $$ConfigTableOrderingComposer,
      $$ConfigTableAnnotationComposer,
      $$ConfigTableCreateCompanionBuilder,
      $$ConfigTableUpdateCompanionBuilder,
      (ConfigData, BaseReferences<_$AppDatabase, $ConfigTable, ConfigData>),
      ConfigData,
      PrefetchHooks Function()
    >;

class $AppDatabaseManager {
  final _$AppDatabase _db;
  $AppDatabaseManager(this._db);
  $$EnfantsTableTableManager get enfants =>
      $$EnfantsTableTableManager(_db, _db.enfants);
  $$ReglesTableTableManager get regles =>
      $$ReglesTableTableManager(_db, _db.regles);
  $$RecompensesTableTableManager get recompenses =>
      $$RecompensesTableTableManager(_db, _db.recompenses);
  $$MouvementsTableTableManager get mouvements =>
      $$MouvementsTableTableManager(_db, _db.mouvements);
  $$ConfigTableTableManager get config =>
      $$ConfigTableTableManager(_db, _db.config);
}