// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'database.dart';

// ignore_for_file: type=lint
class $GameSessionTableTable extends GameSessionTable
    with TableInfo<$GameSessionTableTable, GameSessionTableData> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $GameSessionTableTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<String> id = GeneratedColumn<String>(
      'id', aliasedName, false,
      type: DriftSqlType.string, requiredDuringInsert: true);
  static const VerificationMeta _createdAtMeta =
      const VerificationMeta('createdAt');
  @override
  late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
      'created_at', aliasedName, false,
      type: DriftSqlType.dateTime, requiredDuringInsert: true);
  static const VerificationMeta _gameTitleMeta =
      const VerificationMeta('gameTitle');
  @override
  late final GeneratedColumn<String> gameTitle = GeneratedColumn<String>(
      'game_title', aliasedName, false,
      type: DriftSqlType.string, requiredDuringInsert: true);
  static const VerificationMeta _pointLimitMeta =
      const VerificationMeta('pointLimit');
  @override
  late final GeneratedColumn<int> pointLimit = GeneratedColumn<int>(
      'point_limit', aliasedName, false,
      type: DriftSqlType.int, requiredDuringInsert: true);
  static const VerificationMeta _caboPenaltyMeta =
      const VerificationMeta('caboPenalty');
  @override
  late final GeneratedColumn<int> caboPenalty = GeneratedColumn<int>(
      'cabo_penalty', aliasedName, false,
      type: DriftSqlType.int, requiredDuringInsert: true);
  static const VerificationMeta _isPointsLimitEnabledMeta =
      const VerificationMeta('isPointsLimitEnabled');
  @override
  late final GeneratedColumn<bool> isPointsLimitEnabled = GeneratedColumn<bool>(
      'is_points_limit_enabled', aliasedName, false,
      type: DriftSqlType.bool,
      requiredDuringInsert: true,
      defaultConstraints: GeneratedColumn.constraintIsAlways(
          'CHECK ("is_points_limit_enabled" IN (0, 1))'));
  static const VerificationMeta _isGameFinishedMeta =
      const VerificationMeta('isGameFinished');
  @override
  late final GeneratedColumn<bool> isGameFinished = GeneratedColumn<bool>(
      'is_game_finished', aliasedName, false,
      type: DriftSqlType.bool,
      requiredDuringInsert: true,
      defaultConstraints: GeneratedColumn.constraintIsAlways(
          'CHECK ("is_game_finished" IN (0, 1))'));
  static const VerificationMeta _winnerMeta = const VerificationMeta('winner');
  @override
  late final GeneratedColumn<String> winner = GeneratedColumn<String>(
      'winner', aliasedName, true,
      type: DriftSqlType.string, requiredDuringInsert: false);
  static const VerificationMeta _roundNumberMeta =
      const VerificationMeta('roundNumber');
  @override
  late final GeneratedColumn<int> roundNumber = GeneratedColumn<int>(
      'round_number', aliasedName, false,
      type: DriftSqlType.int, requiredDuringInsert: true);
  @override
  List<GeneratedColumn> get $columns => [
        id,
        createdAt,
        gameTitle,
        pointLimit,
        caboPenalty,
        isPointsLimitEnabled,
        isGameFinished,
        winner,
        roundNumber
      ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'game_session_table';
  @override
  VerificationContext validateIntegrity(
      Insertable<GameSessionTableData> instance,
      {bool isInserting = false}) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    } else if (isInserting) {
      context.missing(_idMeta);
    }
    if (data.containsKey('created_at')) {
      context.handle(_createdAtMeta,
          createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta));
    } else if (isInserting) {
      context.missing(_createdAtMeta);
    }
    if (data.containsKey('game_title')) {
      context.handle(_gameTitleMeta,
          gameTitle.isAcceptableOrUnknown(data['game_title']!, _gameTitleMeta));
    } else if (isInserting) {
      context.missing(_gameTitleMeta);
    }
    if (data.containsKey('point_limit')) {
      context.handle(
          _pointLimitMeta,
          pointLimit.isAcceptableOrUnknown(
              data['point_limit']!, _pointLimitMeta));
    } else if (isInserting) {
      context.missing(_pointLimitMeta);
    }
    if (data.containsKey('cabo_penalty')) {
      context.handle(
          _caboPenaltyMeta,
          caboPenalty.isAcceptableOrUnknown(
              data['cabo_penalty']!, _caboPenaltyMeta));
    } else if (isInserting) {
      context.missing(_caboPenaltyMeta);
    }
    if (data.containsKey('is_points_limit_enabled')) {
      context.handle(
          _isPointsLimitEnabledMeta,
          isPointsLimitEnabled.isAcceptableOrUnknown(
              data['is_points_limit_enabled']!, _isPointsLimitEnabledMeta));
    } else if (isInserting) {
      context.missing(_isPointsLimitEnabledMeta);
    }
    if (data.containsKey('is_game_finished')) {
      context.handle(
          _isGameFinishedMeta,
          isGameFinished.isAcceptableOrUnknown(
              data['is_game_finished']!, _isGameFinishedMeta));
    } else if (isInserting) {
      context.missing(_isGameFinishedMeta);
    }
    if (data.containsKey('winner')) {
      context.handle(_winnerMeta,
          winner.isAcceptableOrUnknown(data['winner']!, _winnerMeta));
    }
    if (data.containsKey('round_number')) {
      context.handle(
          _roundNumberMeta,
          roundNumber.isAcceptableOrUnknown(
              data['round_number']!, _roundNumberMeta));
    } else if (isInserting) {
      context.missing(_roundNumberMeta);
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  GameSessionTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return GameSessionTableData(
      id: attachedDatabase.typeMapping
          .read(DriftSqlType.string, data['${effectivePrefix}id'])!,
      createdAt: attachedDatabase.typeMapping
          .read(DriftSqlType.dateTime, data['${effectivePrefix}created_at'])!,
      gameTitle: attachedDatabase.typeMapping
          .read(DriftSqlType.string, data['${effectivePrefix}game_title'])!,
      pointLimit: attachedDatabase.typeMapping
          .read(DriftSqlType.int, data['${effectivePrefix}point_limit'])!,
      caboPenalty: attachedDatabase.typeMapping
          .read(DriftSqlType.int, data['${effectivePrefix}cabo_penalty'])!,
      isPointsLimitEnabled: attachedDatabase.typeMapping.read(DriftSqlType.bool,
          data['${effectivePrefix}is_points_limit_enabled'])!,
      isGameFinished: attachedDatabase.typeMapping
          .read(DriftSqlType.bool, data['${effectivePrefix}is_game_finished'])!,
      winner: attachedDatabase.typeMapping
          .read(DriftSqlType.string, data['${effectivePrefix}winner']),
      roundNumber: attachedDatabase.typeMapping
          .read(DriftSqlType.int, data['${effectivePrefix}round_number'])!,
    );
  }

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

class GameSessionTableData extends DataClass
    implements Insertable<GameSessionTableData> {
  final String id;
  final DateTime createdAt;
  final String gameTitle;
  final int pointLimit;
  final int caboPenalty;
  final bool isPointsLimitEnabled;
  final bool isGameFinished;
  final String? winner;
  final int roundNumber;
  const GameSessionTableData(
      {required this.id,
      required this.createdAt,
      required this.gameTitle,
      required this.pointLimit,
      required this.caboPenalty,
      required this.isPointsLimitEnabled,
      required this.isGameFinished,
      this.winner,
      required this.roundNumber});
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<String>(id);
    map['created_at'] = Variable<DateTime>(createdAt);
    map['game_title'] = Variable<String>(gameTitle);
    map['point_limit'] = Variable<int>(pointLimit);
    map['cabo_penalty'] = Variable<int>(caboPenalty);
    map['is_points_limit_enabled'] = Variable<bool>(isPointsLimitEnabled);
    map['is_game_finished'] = Variable<bool>(isGameFinished);
    if (!nullToAbsent || winner != null) {
      map['winner'] = Variable<String>(winner);
    }
    map['round_number'] = Variable<int>(roundNumber);
    return map;
  }

  GameSessionTableCompanion toCompanion(bool nullToAbsent) {
    return GameSessionTableCompanion(
      id: Value(id),
      createdAt: Value(createdAt),
      gameTitle: Value(gameTitle),
      pointLimit: Value(pointLimit),
      caboPenalty: Value(caboPenalty),
      isPointsLimitEnabled: Value(isPointsLimitEnabled),
      isGameFinished: Value(isGameFinished),
      winner:
          winner == null && nullToAbsent ? const Value.absent() : Value(winner),
      roundNumber: Value(roundNumber),
    );
  }

  factory GameSessionTableData.fromJson(Map<String, dynamic> json,
      {ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return GameSessionTableData(
      id: serializer.fromJson<String>(json['id']),
      createdAt: serializer.fromJson<DateTime>(json['createdAt']),
      gameTitle: serializer.fromJson<String>(json['gameTitle']),
      pointLimit: serializer.fromJson<int>(json['pointLimit']),
      caboPenalty: serializer.fromJson<int>(json['caboPenalty']),
      isPointsLimitEnabled:
          serializer.fromJson<bool>(json['isPointsLimitEnabled']),
      isGameFinished: serializer.fromJson<bool>(json['isGameFinished']),
      winner: serializer.fromJson<String?>(json['winner']),
      roundNumber: serializer.fromJson<int>(json['roundNumber']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'id': serializer.toJson<String>(id),
      'createdAt': serializer.toJson<DateTime>(createdAt),
      'gameTitle': serializer.toJson<String>(gameTitle),
      'pointLimit': serializer.toJson<int>(pointLimit),
      'caboPenalty': serializer.toJson<int>(caboPenalty),
      'isPointsLimitEnabled': serializer.toJson<bool>(isPointsLimitEnabled),
      'isGameFinished': serializer.toJson<bool>(isGameFinished),
      'winner': serializer.toJson<String?>(winner),
      'roundNumber': serializer.toJson<int>(roundNumber),
    };
  }

  GameSessionTableData copyWith(
          {String? id,
          DateTime? createdAt,
          String? gameTitle,
          int? pointLimit,
          int? caboPenalty,
          bool? isPointsLimitEnabled,
          bool? isGameFinished,
          Value<String?> winner = const Value.absent(),
          int? roundNumber}) =>
      GameSessionTableData(
        id: id ?? this.id,
        createdAt: createdAt ?? this.createdAt,
        gameTitle: gameTitle ?? this.gameTitle,
        pointLimit: pointLimit ?? this.pointLimit,
        caboPenalty: caboPenalty ?? this.caboPenalty,
        isPointsLimitEnabled: isPointsLimitEnabled ?? this.isPointsLimitEnabled,
        isGameFinished: isGameFinished ?? this.isGameFinished,
        winner: winner.present ? winner.value : this.winner,
        roundNumber: roundNumber ?? this.roundNumber,
      );
  GameSessionTableData copyWithCompanion(GameSessionTableCompanion data) {
    return GameSessionTableData(
      id: data.id.present ? data.id.value : this.id,
      createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
      gameTitle: data.gameTitle.present ? data.gameTitle.value : this.gameTitle,
      pointLimit:
          data.pointLimit.present ? data.pointLimit.value : this.pointLimit,
      caboPenalty:
          data.caboPenalty.present ? data.caboPenalty.value : this.caboPenalty,
      isPointsLimitEnabled: data.isPointsLimitEnabled.present
          ? data.isPointsLimitEnabled.value
          : this.isPointsLimitEnabled,
      isGameFinished: data.isGameFinished.present
          ? data.isGameFinished.value
          : this.isGameFinished,
      winner: data.winner.present ? data.winner.value : this.winner,
      roundNumber:
          data.roundNumber.present ? data.roundNumber.value : this.roundNumber,
    );
  }

  @override
  String toString() {
    return (StringBuffer('GameSessionTableData(')
          ..write('id: $id, ')
          ..write('createdAt: $createdAt, ')
          ..write('gameTitle: $gameTitle, ')
          ..write('pointLimit: $pointLimit, ')
          ..write('caboPenalty: $caboPenalty, ')
          ..write('isPointsLimitEnabled: $isPointsLimitEnabled, ')
          ..write('isGameFinished: $isGameFinished, ')
          ..write('winner: $winner, ')
          ..write('roundNumber: $roundNumber')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(id, createdAt, gameTitle, pointLimit,
      caboPenalty, isPointsLimitEnabled, isGameFinished, winner, roundNumber);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is GameSessionTableData &&
          other.id == this.id &&
          other.createdAt == this.createdAt &&
          other.gameTitle == this.gameTitle &&
          other.pointLimit == this.pointLimit &&
          other.caboPenalty == this.caboPenalty &&
          other.isPointsLimitEnabled == this.isPointsLimitEnabled &&
          other.isGameFinished == this.isGameFinished &&
          other.winner == this.winner &&
          other.roundNumber == this.roundNumber);
}

class GameSessionTableCompanion extends UpdateCompanion<GameSessionTableData> {
  final Value<String> id;
  final Value<DateTime> createdAt;
  final Value<String> gameTitle;
  final Value<int> pointLimit;
  final Value<int> caboPenalty;
  final Value<bool> isPointsLimitEnabled;
  final Value<bool> isGameFinished;
  final Value<String?> winner;
  final Value<int> roundNumber;
  final Value<int> rowid;
  const GameSessionTableCompanion({
    this.id = const Value.absent(),
    this.createdAt = const Value.absent(),
    this.gameTitle = const Value.absent(),
    this.pointLimit = const Value.absent(),
    this.caboPenalty = const Value.absent(),
    this.isPointsLimitEnabled = const Value.absent(),
    this.isGameFinished = const Value.absent(),
    this.winner = const Value.absent(),
    this.roundNumber = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  GameSessionTableCompanion.insert({
    required String id,
    required DateTime createdAt,
    required String gameTitle,
    required int pointLimit,
    required int caboPenalty,
    required bool isPointsLimitEnabled,
    required bool isGameFinished,
    this.winner = const Value.absent(),
    required int roundNumber,
    this.rowid = const Value.absent(),
  })  : id = Value(id),
        createdAt = Value(createdAt),
        gameTitle = Value(gameTitle),
        pointLimit = Value(pointLimit),
        caboPenalty = Value(caboPenalty),
        isPointsLimitEnabled = Value(isPointsLimitEnabled),
        isGameFinished = Value(isGameFinished),
        roundNumber = Value(roundNumber);
  static Insertable<GameSessionTableData> custom({
    Expression<String>? id,
    Expression<DateTime>? createdAt,
    Expression<String>? gameTitle,
    Expression<int>? pointLimit,
    Expression<int>? caboPenalty,
    Expression<bool>? isPointsLimitEnabled,
    Expression<bool>? isGameFinished,
    Expression<String>? winner,
    Expression<int>? roundNumber,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (createdAt != null) 'created_at': createdAt,
      if (gameTitle != null) 'game_title': gameTitle,
      if (pointLimit != null) 'point_limit': pointLimit,
      if (caboPenalty != null) 'cabo_penalty': caboPenalty,
      if (isPointsLimitEnabled != null)
        'is_points_limit_enabled': isPointsLimitEnabled,
      if (isGameFinished != null) 'is_game_finished': isGameFinished,
      if (winner != null) 'winner': winner,
      if (roundNumber != null) 'round_number': roundNumber,
      if (rowid != null) 'rowid': rowid,
    });
  }

  GameSessionTableCompanion copyWith(
      {Value<String>? id,
      Value<DateTime>? createdAt,
      Value<String>? gameTitle,
      Value<int>? pointLimit,
      Value<int>? caboPenalty,
      Value<bool>? isPointsLimitEnabled,
      Value<bool>? isGameFinished,
      Value<String?>? winner,
      Value<int>? roundNumber,
      Value<int>? rowid}) {
    return GameSessionTableCompanion(
      id: id ?? this.id,
      createdAt: createdAt ?? this.createdAt,
      gameTitle: gameTitle ?? this.gameTitle,
      pointLimit: pointLimit ?? this.pointLimit,
      caboPenalty: caboPenalty ?? this.caboPenalty,
      isPointsLimitEnabled: isPointsLimitEnabled ?? this.isPointsLimitEnabled,
      isGameFinished: isGameFinished ?? this.isGameFinished,
      winner: winner ?? this.winner,
      roundNumber: roundNumber ?? this.roundNumber,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<String>(id.value);
    }
    if (createdAt.present) {
      map['created_at'] = Variable<DateTime>(createdAt.value);
    }
    if (gameTitle.present) {
      map['game_title'] = Variable<String>(gameTitle.value);
    }
    if (pointLimit.present) {
      map['point_limit'] = Variable<int>(pointLimit.value);
    }
    if (caboPenalty.present) {
      map['cabo_penalty'] = Variable<int>(caboPenalty.value);
    }
    if (isPointsLimitEnabled.present) {
      map['is_points_limit_enabled'] =
          Variable<bool>(isPointsLimitEnabled.value);
    }
    if (isGameFinished.present) {
      map['is_game_finished'] = Variable<bool>(isGameFinished.value);
    }
    if (winner.present) {
      map['winner'] = Variable<String>(winner.value);
    }
    if (roundNumber.present) {
      map['round_number'] = Variable<int>(roundNumber.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('GameSessionTableCompanion(')
          ..write('id: $id, ')
          ..write('createdAt: $createdAt, ')
          ..write('gameTitle: $gameTitle, ')
          ..write('pointLimit: $pointLimit, ')
          ..write('caboPenalty: $caboPenalty, ')
          ..write('isPointsLimitEnabled: $isPointsLimitEnabled, ')
          ..write('isGameFinished: $isGameFinished, ')
          ..write('winner: $winner, ')
          ..write('roundNumber: $roundNumber, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $PlayersTableTable extends PlayersTable
    with TableInfo<$PlayersTableTable, PlayersTableData> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $PlayersTableTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<String> playerId = GeneratedColumn<String>(
      'id', aliasedName, false,
      type: DriftSqlType.string,
      requiredDuringInsert: true,
      defaultConstraints: GeneratedColumn.constraintIsAlways(
          'REFERENCES game_session_table (id) ON DELETE CASCADE'));
  static const VerificationMeta _nameMeta = const VerificationMeta('name');
  @override
  late final GeneratedColumn<String> name = GeneratedColumn<String>(
      'name', aliasedName, false,
      type: DriftSqlType.string, requiredDuringInsert: true);
  @override
  List<GeneratedColumn> get $columns => [playerId, name];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'players_table';
  @override
  VerificationContext validateIntegrity(Insertable<PlayersTableData> instance,
      {bool isInserting = false}) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, playerId.isAcceptableOrUnknown(data['id']!, _idMeta));
    } else if (isInserting) {
      context.missing(_idMeta);
    }
    if (data.containsKey('name')) {
      context.handle(
          _nameMeta, name.isAcceptableOrUnknown(data['name']!, _nameMeta));
    } else if (isInserting) {
      context.missing(_nameMeta);
    }
    return context;
  }

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

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

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

  PlayersTableCompanion toCompanion(bool nullToAbsent) {
    return PlayersTableCompanion(
      id: Value(id),
      name: Value(name),
    );
  }

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

  PlayersTableData copyWith({String? id, String? name}) => PlayersTableData(
        id: id ?? this.id,
        name: name ?? this.name,
      );
  PlayersTableData copyWithCompanion(PlayersTableCompanion data) {
    return PlayersTableData(
      id: data.id.present ? data.id.value : this.id,
      name: data.name.present ? data.name.value : this.name,
    );
  }

  @override
  String toString() {
    return (StringBuffer('PlayersTableData(')
          ..write('id: $id, ')
          ..write('name: $name')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(id, name);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is PlayersTableData &&
          other.id == this.id &&
          other.name == this.name);
}

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

  PlayersTableCompanion copyWith(
      {Value<String>? id, Value<String>? name, Value<int>? rowid}) {
    return PlayersTableCompanion(
      id: id ?? this.id,
      name: name ?? this.name,
      rowid: rowid ?? this.rowid,
    );
  }

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

  @override
  String toString() {
    return (StringBuffer('PlayersTableCompanion(')
          ..write('id: $id, ')
          ..write('name: $name, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $PlayerScoresTableTable extends PlayerScoresTable
    with TableInfo<$PlayerScoresTableTable, PlayerScoresTableData> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $PlayerScoresTableTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _roundIdMeta =
      const VerificationMeta('roundId');
  @override
  late final GeneratedColumn<String> roundId = GeneratedColumn<String>(
      'round_id', aliasedName, false,
      type: DriftSqlType.string,
      requiredDuringInsert: true,
      defaultConstraints: GeneratedColumn.constraintIsAlways(
          'REFERENCES game_session_table (id) ON DELETE CASCADE'));
  static const VerificationMeta _playerNameMeta =
      const VerificationMeta('playerName');
  @override
  late final GeneratedColumn<String> playerName = GeneratedColumn<String>(
      'player_name', aliasedName, false,
      type: DriftSqlType.string,
      requiredDuringInsert: true,
      defaultConstraints: GeneratedColumn.constraintIsAlways(
          'REFERENCES players_table (name)'));
  static const VerificationMeta _totalScoreMeta =
      const VerificationMeta('totalScore');
  @override
  late final GeneratedColumn<int> totalScore = GeneratedColumn<int>(
      'total_score', aliasedName, false,
      type: DriftSqlType.int, requiredDuringInsert: true);
  @override
  List<GeneratedColumn> get $columns => [roundId, playerName, totalScore];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'player_scores_table';
  @override
  VerificationContext validateIntegrity(
      Insertable<PlayerScoresTableData> instance,
      {bool isInserting = false}) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('round_id')) {
      context.handle(_roundIdMeta,
          roundId.isAcceptableOrUnknown(data['round_id']!, _roundIdMeta));
    } else if (isInserting) {
      context.missing(_roundIdMeta);
    }
    if (data.containsKey('player_name')) {
      context.handle(
          _playerNameMeta,
          playerName.isAcceptableOrUnknown(
              data['player_name']!, _playerNameMeta));
    } else if (isInserting) {
      context.missing(_playerNameMeta);
    }
    if (data.containsKey('total_score')) {
      context.handle(
          _totalScoreMeta,
          totalScore.isAcceptableOrUnknown(
              data['total_score']!, _totalScoreMeta));
    } else if (isInserting) {
      context.missing(_totalScoreMeta);
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {roundId, playerName};
  @override
  PlayerScoresTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return PlayerScoresTableData(
      roundId: attachedDatabase.typeMapping
          .read(DriftSqlType.string, data['${effectivePrefix}round_id'])!,
      playerName: attachedDatabase.typeMapping
          .read(DriftSqlType.string, data['${effectivePrefix}player_name'])!,
      totalScore: attachedDatabase.typeMapping
          .read(DriftSqlType.int, data['${effectivePrefix}total_score'])!,
    );
  }

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

class PlayerScoresTableData extends DataClass
    implements Insertable<PlayerScoresTableData> {
  final String roundId;
  final String playerName;
  final int totalScore;
  const PlayerScoresTableData(
      {required this.roundId,
      required this.playerName,
      required this.totalScore});
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['round_id'] = Variable<String>(roundId);
    map['player_name'] = Variable<String>(playerName);
    map['total_score'] = Variable<int>(totalScore);
    return map;
  }

  PlayerScoresTableCompanion toCompanion(bool nullToAbsent) {
    return PlayerScoresTableCompanion(
      roundId: Value(roundId),
      playerName: Value(playerName),
      totalScore: Value(totalScore),
    );
  }

  factory PlayerScoresTableData.fromJson(Map<String, dynamic> json,
      {ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return PlayerScoresTableData(
      roundId: serializer.fromJson<String>(json['roundId']),
      playerName: serializer.fromJson<String>(json['playerName']),
      totalScore: serializer.fromJson<int>(json['totalScore']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'roundId': serializer.toJson<String>(roundId),
      'playerName': serializer.toJson<String>(playerName),
      'totalScore': serializer.toJson<int>(totalScore),
    };
  }

  PlayerScoresTableData copyWith(
          {String? roundId, String? playerName, int? totalScore}) =>
      PlayerScoresTableData(
        roundId: roundId ?? this.roundId,
        playerName: playerName ?? this.playerName,
        totalScore: totalScore ?? this.totalScore,
      );
  PlayerScoresTableData copyWithCompanion(PlayerScoresTableCompanion data) {
    return PlayerScoresTableData(
      roundId: data.roundId.present ? data.roundId.value : this.roundId,
      playerName:
          data.playerName.present ? data.playerName.value : this.playerName,
      totalScore:
          data.totalScore.present ? data.totalScore.value : this.totalScore,
    );
  }

  @override
  String toString() {
    return (StringBuffer('PlayerScoresTableData(')
          ..write('roundId: $roundId, ')
          ..write('playerName: $playerName, ')
          ..write('totalScore: $totalScore')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(roundId, playerName, totalScore);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is PlayerScoresTableData &&
          other.roundId == this.roundId &&
          other.playerName == this.playerName &&
          other.totalScore == this.totalScore);
}

class PlayerScoresTableCompanion
    extends UpdateCompanion<PlayerScoresTableData> {
  final Value<String> roundId;
  final Value<String> playerName;
  final Value<int> totalScore;
  final Value<int> rowid;
  const PlayerScoresTableCompanion({
    this.roundId = const Value.absent(),
    this.playerName = const Value.absent(),
    this.totalScore = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  PlayerScoresTableCompanion.insert({
    required String roundId,
    required String playerName,
    required int totalScore,
    this.rowid = const Value.absent(),
  })  : roundId = Value(roundId),
        playerName = Value(playerName),
        totalScore = Value(totalScore);
  static Insertable<PlayerScoresTableData> custom({
    Expression<String>? roundId,
    Expression<String>? playerName,
    Expression<int>? totalScore,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (roundId != null) 'round_id': roundId,
      if (playerName != null) 'player_name': playerName,
      if (totalScore != null) 'total_score': totalScore,
      if (rowid != null) 'rowid': rowid,
    });
  }

  PlayerScoresTableCompanion copyWith(
      {Value<String>? roundId,
      Value<String>? playerName,
      Value<int>? totalScore,
      Value<int>? rowid}) {
    return PlayerScoresTableCompanion(
      roundId: roundId ?? this.roundId,
      playerName: playerName ?? this.playerName,
      totalScore: totalScore ?? this.totalScore,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (roundId.present) {
      map['round_id'] = Variable<String>(roundId.value);
    }
    if (playerName.present) {
      map['player_name'] = Variable<String>(playerName.value);
    }
    if (totalScore.present) {
      map['total_score'] = Variable<int>(totalScore.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('PlayerScoresTableCompanion(')
          ..write('roundId: $roundId, ')
          ..write('playerName: $playerName, ')
          ..write('totalScore: $totalScore, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $RoundsTableTable extends RoundsTable
    with TableInfo<$RoundsTableTable, RoundsTableData> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $RoundsTableTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<String> id = GeneratedColumn<String>(
      'id', aliasedName, false,
      type: DriftSqlType.string, requiredDuringInsert: true);
  static const VerificationMeta _gameIdMeta = const VerificationMeta('gameId');
  @override
  late final GeneratedColumn<String> gameId = GeneratedColumn<String>(
      'game_id', aliasedName, false,
      type: DriftSqlType.string,
      requiredDuringInsert: true,
      defaultConstraints: GeneratedColumn.constraintIsAlways(
          'REFERENCES game_session_table (id) ON DELETE CASCADE'));
  static const VerificationMeta _roundNumberMeta =
      const VerificationMeta('roundNumber');
  @override
  late final GeneratedColumn<int> roundNumber = GeneratedColumn<int>(
      'round_number', aliasedName, false,
      type: DriftSqlType.int, requiredDuringInsert: true);
  static const VerificationMeta _kamikazePlayerMeta =
      const VerificationMeta('kamikazePlayer');
  @override
  late final GeneratedColumn<String> kamikazePlayer = GeneratedColumn<String>(
      'kamikaze_player', aliasedName, true,
      type: DriftSqlType.string, requiredDuringInsert: false);
  @override
  List<GeneratedColumn> get $columns =>
      [id, gameId, roundNumber, kamikazePlayer];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'rounds_table';
  @override
  VerificationContext validateIntegrity(Insertable<RoundsTableData> instance,
      {bool isInserting = false}) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    } else if (isInserting) {
      context.missing(_idMeta);
    }
    if (data.containsKey('game_id')) {
      context.handle(_gameIdMeta,
          gameId.isAcceptableOrUnknown(data['game_id']!, _gameIdMeta));
    } else if (isInserting) {
      context.missing(_gameIdMeta);
    }
    if (data.containsKey('round_number')) {
      context.handle(
          _roundNumberMeta,
          roundNumber.isAcceptableOrUnknown(
              data['round_number']!, _roundNumberMeta));
    } else if (isInserting) {
      context.missing(_roundNumberMeta);
    }
    if (data.containsKey('kamikaze_player')) {
      context.handle(
          _kamikazePlayerMeta,
          kamikazePlayer.isAcceptableOrUnknown(
              data['kamikaze_player']!, _kamikazePlayerMeta));
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  RoundsTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return RoundsTableData(
      id: attachedDatabase.typeMapping
          .read(DriftSqlType.string, data['${effectivePrefix}id'])!,
      gameId: attachedDatabase.typeMapping
          .read(DriftSqlType.string, data['${effectivePrefix}game_id'])!,
      roundNumber: attachedDatabase.typeMapping
          .read(DriftSqlType.int, data['${effectivePrefix}round_number'])!,
      kamikazePlayer: attachedDatabase.typeMapping
          .read(DriftSqlType.string, data['${effectivePrefix}kamikaze_player']),
    );
  }

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

class RoundsTableData extends DataClass implements Insertable<RoundsTableData> {
  final String id;
  final String gameId;
  final int roundNumber;
  final String? kamikazePlayer;
  const RoundsTableData(
      {required this.id,
      required this.gameId,
      required this.roundNumber,
      this.kamikazePlayer});
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<String>(id);
    map['game_id'] = Variable<String>(gameId);
    map['round_number'] = Variable<int>(roundNumber);
    if (!nullToAbsent || kamikazePlayer != null) {
      map['kamikaze_player'] = Variable<String>(kamikazePlayer);
    }
    return map;
  }

  RoundsTableCompanion toCompanion(bool nullToAbsent) {
    return RoundsTableCompanion(
      id: Value(id),
      gameId: Value(gameId),
      roundNumber: Value(roundNumber),
      kamikazePlayer: kamikazePlayer == null && nullToAbsent
          ? const Value.absent()
          : Value(kamikazePlayer),
    );
  }

  factory RoundsTableData.fromJson(Map<String, dynamic> json,
      {ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return RoundsTableData(
      id: serializer.fromJson<String>(json['id']),
      gameId: serializer.fromJson<String>(json['gameId']),
      roundNumber: serializer.fromJson<int>(json['roundNumber']),
      kamikazePlayer: serializer.fromJson<String?>(json['kamikazePlayer']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'id': serializer.toJson<String>(id),
      'gameId': serializer.toJson<String>(gameId),
      'roundNumber': serializer.toJson<int>(roundNumber),
      'kamikazePlayer': serializer.toJson<String?>(kamikazePlayer),
    };
  }

  RoundsTableData copyWith(
          {String? id,
          String? gameId,
          int? roundNumber,
          Value<String?> kamikazePlayer = const Value.absent()}) =>
      RoundsTableData(
        id: id ?? this.id,
        gameId: gameId ?? this.gameId,
        roundNumber: roundNumber ?? this.roundNumber,
        kamikazePlayer:
            kamikazePlayer.present ? kamikazePlayer.value : this.kamikazePlayer,
      );
  RoundsTableData copyWithCompanion(RoundsTableCompanion data) {
    return RoundsTableData(
      id: data.id.present ? data.id.value : this.id,
      gameId: data.gameId.present ? data.gameId.value : this.gameId,
      roundNumber:
          data.roundNumber.present ? data.roundNumber.value : this.roundNumber,
      kamikazePlayer: data.kamikazePlayer.present
          ? data.kamikazePlayer.value
          : this.kamikazePlayer,
    );
  }

  @override
  String toString() {
    return (StringBuffer('RoundsTableData(')
          ..write('id: $id, ')
          ..write('gameId: $gameId, ')
          ..write('roundNumber: $roundNumber, ')
          ..write('kamikazePlayer: $kamikazePlayer')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(id, gameId, roundNumber, kamikazePlayer);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is RoundsTableData &&
          other.id == this.id &&
          other.gameId == this.gameId &&
          other.roundNumber == this.roundNumber &&
          other.kamikazePlayer == this.kamikazePlayer);
}

class RoundsTableCompanion extends UpdateCompanion<RoundsTableData> {
  final Value<String> id;
  final Value<String> gameId;
  final Value<int> roundNumber;
  final Value<String?> kamikazePlayer;
  final Value<int> rowid;
  const RoundsTableCompanion({
    this.id = const Value.absent(),
    this.gameId = const Value.absent(),
    this.roundNumber = const Value.absent(),
    this.kamikazePlayer = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  RoundsTableCompanion.insert({
    required String id,
    required String gameId,
    required int roundNumber,
    this.kamikazePlayer = const Value.absent(),
    this.rowid = const Value.absent(),
  })  : id = Value(id),
        gameId = Value(gameId),
        roundNumber = Value(roundNumber);
  static Insertable<RoundsTableData> custom({
    Expression<String>? id,
    Expression<String>? gameId,
    Expression<int>? roundNumber,
    Expression<String>? kamikazePlayer,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (gameId != null) 'game_id': gameId,
      if (roundNumber != null) 'round_number': roundNumber,
      if (kamikazePlayer != null) 'kamikaze_player': kamikazePlayer,
      if (rowid != null) 'rowid': rowid,
    });
  }

  RoundsTableCompanion copyWith(
      {Value<String>? id,
      Value<String>? gameId,
      Value<int>? roundNumber,
      Value<String?>? kamikazePlayer,
      Value<int>? rowid}) {
    return RoundsTableCompanion(
      id: id ?? this.id,
      gameId: gameId ?? this.gameId,
      roundNumber: roundNumber ?? this.roundNumber,
      kamikazePlayer: kamikazePlayer ?? this.kamikazePlayer,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<String>(id.value);
    }
    if (gameId.present) {
      map['game_id'] = Variable<String>(gameId.value);
    }
    if (roundNumber.present) {
      map['round_number'] = Variable<int>(roundNumber.value);
    }
    if (kamikazePlayer.present) {
      map['kamikaze_player'] = Variable<String>(kamikazePlayer.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('RoundsTableCompanion(')
          ..write('id: $id, ')
          ..write('gameId: $gameId, ')
          ..write('roundNumber: $roundNumber, ')
          ..write('kamikazePlayer: $kamikazePlayer, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $RoundScoresTableTable extends RoundScoresTable
    with TableInfo<$RoundScoresTableTable, RoundScoresTableData> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $RoundScoresTableTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _roundIdMeta =
      const VerificationMeta('roundId');
  @override
  late final GeneratedColumn<String> roundId = GeneratedColumn<String>(
      'round_id', aliasedName, false,
      type: DriftSqlType.string,
      requiredDuringInsert: true,
      defaultConstraints: GeneratedColumn.constraintIsAlways(
          'REFERENCES rounds_table (id) ON DELETE CASCADE'));
  static const VerificationMeta _playerNameMeta =
      const VerificationMeta('playerName');
  @override
  late final GeneratedColumn<String> playerName = GeneratedColumn<String>(
      'player_name', aliasedName, false,
      type: DriftSqlType.string, requiredDuringInsert: true);
  static const VerificationMeta _scoreMeta = const VerificationMeta('score');
  @override
  late final GeneratedColumn<int> score = GeneratedColumn<int>(
      'score', aliasedName, false,
      type: DriftSqlType.int, requiredDuringInsert: true);
  static const VerificationMeta _scoreUpdateMeta =
      const VerificationMeta('scoreUpdate');
  @override
  late final GeneratedColumn<int> scoreUpdate = GeneratedColumn<int>(
      'score_update', aliasedName, false,
      type: DriftSqlType.int, requiredDuringInsert: true);
  @override
  List<GeneratedColumn> get $columns =>
      [roundId, playerName, score, scoreUpdate];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'round_scores_table';
  @override
  VerificationContext validateIntegrity(
      Insertable<RoundScoresTableData> instance,
      {bool isInserting = false}) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('round_id')) {
      context.handle(_roundIdMeta,
          roundId.isAcceptableOrUnknown(data['round_id']!, _roundIdMeta));
    } else if (isInserting) {
      context.missing(_roundIdMeta);
    }
    if (data.containsKey('player_name')) {
      context.handle(
          _playerNameMeta,
          playerName.isAcceptableOrUnknown(
              data['player_name']!, _playerNameMeta));
    } else if (isInserting) {
      context.missing(_playerNameMeta);
    }
    if (data.containsKey('score')) {
      context.handle(
          _scoreMeta, score.isAcceptableOrUnknown(data['score']!, _scoreMeta));
    } else if (isInserting) {
      context.missing(_scoreMeta);
    }
    if (data.containsKey('score_update')) {
      context.handle(
          _scoreUpdateMeta,
          scoreUpdate.isAcceptableOrUnknown(
              data['score_update']!, _scoreUpdateMeta));
    } else if (isInserting) {
      context.missing(_scoreUpdateMeta);
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {roundId, playerName};
  @override
  RoundScoresTableData map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return RoundScoresTableData(
      roundId: attachedDatabase.typeMapping
          .read(DriftSqlType.string, data['${effectivePrefix}round_id'])!,
      playerName: attachedDatabase.typeMapping
          .read(DriftSqlType.string, data['${effectivePrefix}player_name'])!,
      score: attachedDatabase.typeMapping
          .read(DriftSqlType.int, data['${effectivePrefix}score'])!,
      scoreUpdate: attachedDatabase.typeMapping
          .read(DriftSqlType.int, data['${effectivePrefix}score_update'])!,
    );
  }

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

class RoundScoresTableData extends DataClass
    implements Insertable<RoundScoresTableData> {
  final String roundId;
  final String playerName;
  final int score;
  final int scoreUpdate;
  const RoundScoresTableData(
      {required this.roundId,
      required this.playerName,
      required this.score,
      required this.scoreUpdate});
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['round_id'] = Variable<String>(roundId);
    map['player_name'] = Variable<String>(playerName);
    map['score'] = Variable<int>(score);
    map['score_update'] = Variable<int>(scoreUpdate);
    return map;
  }

  RoundScoresTableCompanion toCompanion(bool nullToAbsent) {
    return RoundScoresTableCompanion(
      roundId: Value(roundId),
      playerName: Value(playerName),
      score: Value(score),
      scoreUpdate: Value(scoreUpdate),
    );
  }

  factory RoundScoresTableData.fromJson(Map<String, dynamic> json,
      {ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return RoundScoresTableData(
      roundId: serializer.fromJson<String>(json['roundId']),
      playerName: serializer.fromJson<String>(json['playerName']),
      score: serializer.fromJson<int>(json['score']),
      scoreUpdate: serializer.fromJson<int>(json['scoreUpdate']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'roundId': serializer.toJson<String>(roundId),
      'playerName': serializer.toJson<String>(playerName),
      'score': serializer.toJson<int>(score),
      'scoreUpdate': serializer.toJson<int>(scoreUpdate),
    };
  }

  RoundScoresTableData copyWith(
          {String? roundId,
          String? playerName,
          int? score,
          int? scoreUpdate}) =>
      RoundScoresTableData(
        roundId: roundId ?? this.roundId,
        playerName: playerName ?? this.playerName,
        score: score ?? this.score,
        scoreUpdate: scoreUpdate ?? this.scoreUpdate,
      );
  RoundScoresTableData copyWithCompanion(RoundScoresTableCompanion data) {
    return RoundScoresTableData(
      roundId: data.roundId.present ? data.roundId.value : this.roundId,
      playerName:
          data.playerName.present ? data.playerName.value : this.playerName,
      score: data.score.present ? data.score.value : this.score,
      scoreUpdate:
          data.scoreUpdate.present ? data.scoreUpdate.value : this.scoreUpdate,
    );
  }

  @override
  String toString() {
    return (StringBuffer('RoundScoresTableData(')
          ..write('roundId: $roundId, ')
          ..write('playerName: $playerName, ')
          ..write('score: $score, ')
          ..write('scoreUpdate: $scoreUpdate')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(roundId, playerName, score, scoreUpdate);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is RoundScoresTableData &&
          other.roundId == this.roundId &&
          other.playerName == this.playerName &&
          other.score == this.score &&
          other.scoreUpdate == this.scoreUpdate);
}

class RoundScoresTableCompanion extends UpdateCompanion<RoundScoresTableData> {
  final Value<String> roundId;
  final Value<String> playerName;
  final Value<int> score;
  final Value<int> scoreUpdate;
  final Value<int> rowid;
  const RoundScoresTableCompanion({
    this.roundId = const Value.absent(),
    this.playerName = const Value.absent(),
    this.score = const Value.absent(),
    this.scoreUpdate = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  RoundScoresTableCompanion.insert({
    required String roundId,
    required String playerName,
    required int score,
    required int scoreUpdate,
    this.rowid = const Value.absent(),
  })  : roundId = Value(roundId),
        playerName = Value(playerName),
        score = Value(score),
        scoreUpdate = Value(scoreUpdate);
  static Insertable<RoundScoresTableData> custom({
    Expression<String>? roundId,
    Expression<String>? playerName,
    Expression<int>? score,
    Expression<int>? scoreUpdate,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (roundId != null) 'round_id': roundId,
      if (playerName != null) 'player_name': playerName,
      if (score != null) 'score': score,
      if (scoreUpdate != null) 'score_update': scoreUpdate,
      if (rowid != null) 'rowid': rowid,
    });
  }

  RoundScoresTableCompanion copyWith(
      {Value<String>? roundId,
      Value<String>? playerName,
      Value<int>? score,
      Value<int>? scoreUpdate,
      Value<int>? rowid}) {
    return RoundScoresTableCompanion(
      roundId: roundId ?? this.roundId,
      playerName: playerName ?? this.playerName,
      score: score ?? this.score,
      scoreUpdate: scoreUpdate ?? this.scoreUpdate,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (roundId.present) {
      map['round_id'] = Variable<String>(roundId.value);
    }
    if (playerName.present) {
      map['player_name'] = Variable<String>(playerName.value);
    }
    if (score.present) {
      map['score'] = Variable<int>(score.value);
    }
    if (scoreUpdate.present) {
      map['score_update'] = Variable<int>(scoreUpdate.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('RoundScoresTableCompanion(')
          ..write('roundId: $roundId, ')
          ..write('playerName: $playerName, ')
          ..write('score: $score, ')
          ..write('scoreUpdate: $scoreUpdate, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

abstract class _$AppDatabase extends GeneratedDatabase {
  _$AppDatabase(QueryExecutor e) : super(e);
  $AppDatabaseManager get managers => $AppDatabaseManager(this);
  late final $GameSessionTableTable gameSessionTable =
      $GameSessionTableTable(this);
  late final $PlayersTableTable playersTable = $PlayersTableTable(this);
  late final $PlayerScoresTableTable playerScoresTable =
      $PlayerScoresTableTable(this);
  late final $RoundsTableTable roundsTable = $RoundsTableTable(this);
  late final $RoundScoresTableTable roundScoresTable =
      $RoundScoresTableTable(this);
  @override
  Iterable<TableInfo<Table, Object?>> get allTables =>
      allSchemaEntities.whereType<TableInfo<Table, Object?>>();
  @override
  List<DatabaseSchemaEntity> get allSchemaEntities => [
        gameSessionTable,
        playersTable,
        playerScoresTable,
        roundsTable,
        roundScoresTable
      ];
  @override
  StreamQueryUpdateRules get streamUpdateRules => const StreamQueryUpdateRules(
        [
          WritePropagation(
            on: TableUpdateQuery.onTableName('game_session_table',
                limitUpdateKind: UpdateKind.delete),
            result: [
              TableUpdate('players_table', kind: UpdateKind.delete),
            ],
          ),
          WritePropagation(
            on: TableUpdateQuery.onTableName('game_session_table',
                limitUpdateKind: UpdateKind.delete),
            result: [
              TableUpdate('player_scores_table', kind: UpdateKind.delete),
            ],
          ),
          WritePropagation(
            on: TableUpdateQuery.onTableName('game_session_table',
                limitUpdateKind: UpdateKind.delete),
            result: [
              TableUpdate('rounds_table', kind: UpdateKind.delete),
            ],
          ),
          WritePropagation(
            on: TableUpdateQuery.onTableName('rounds_table',
                limitUpdateKind: UpdateKind.delete),
            result: [
              TableUpdate('round_scores_table', kind: UpdateKind.delete),
            ],
          ),
        ],
      );
}

typedef $$GameSessionTableTableCreateCompanionBuilder
    = GameSessionTableCompanion Function({
  required String id,
  required DateTime createdAt,
  required String gameTitle,
  required int pointLimit,
  required int caboPenalty,
  required bool isPointsLimitEnabled,
  required bool isGameFinished,
  Value<String?> winner,
  required int roundNumber,
  Value<int> rowid,
});
typedef $$GameSessionTableTableUpdateCompanionBuilder
    = GameSessionTableCompanion Function({
  Value<String> id,
  Value<DateTime> createdAt,
  Value<String> gameTitle,
  Value<int> pointLimit,
  Value<int> caboPenalty,
  Value<bool> isPointsLimitEnabled,
  Value<bool> isGameFinished,
  Value<String?> winner,
  Value<int> roundNumber,
  Value<int> rowid,
});

final class $$GameSessionTableTableReferences extends BaseReferences<
    _$AppDatabase, $GameSessionTableTable, GameSessionTableData> {
  $$GameSessionTableTableReferences(
      super.$_db, super.$_table, super.$_typedResult);

  static MultiTypedResultKey<$PlayersTableTable, List<PlayersTableData>>
      _playersTableRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
          db.playersTable,
          aliasName:
              $_aliasNameGenerator(db.gameSessionTable.id, db.playersTable.playerId));

  $$PlayersTableTableProcessedTableManager get playersTableRefs {
    final manager = $$PlayersTableTableTableManager($_db, $_db.playersTable)
        .filter((f) => f.id.id.sqlEquals($_itemColumn<String>('id')!));

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

  static MultiTypedResultKey<$PlayerScoresTableTable,
      List<PlayerScoresTableData>> _playerScoresTableRefsTable(
          _$AppDatabase db) =>
      MultiTypedResultKey.fromTable(db.playerScoresTable,
          aliasName: $_aliasNameGenerator(
              db.gameSessionTable.id, db.playerScoresTable.roundId));

  $$PlayerScoresTableTableProcessedTableManager get playerScoresTableRefs {
    final manager =
        $$PlayerScoresTableTableTableManager($_db, $_db.playerScoresTable)
            .filter((f) => f.roundId.id.sqlEquals($_itemColumn<String>('id')!));

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

  static MultiTypedResultKey<$RoundsTableTable, List<RoundsTableData>>
      _roundsTableRefsTable(_$AppDatabase db) =>
          MultiTypedResultKey.fromTable(db.roundsTable,
              aliasName: $_aliasNameGenerator(
                  db.gameSessionTable.id, db.roundsTable.gameId));

  $$RoundsTableTableProcessedTableManager get roundsTableRefs {
    final manager = $$RoundsTableTableTableManager($_db, $_db.roundsTable)
        .filter((f) => f.gameId.id.sqlEquals($_itemColumn<String>('id')!));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class $$GameSessionTableTableTableManager extends RootTableManager<
    _$AppDatabase,
    $GameSessionTableTable,
    GameSessionTableData,
    $$GameSessionTableTableFilterComposer,
    $$GameSessionTableTableOrderingComposer,
    $$GameSessionTableTableAnnotationComposer,
    $$GameSessionTableTableCreateCompanionBuilder,
    $$GameSessionTableTableUpdateCompanionBuilder,
    (GameSessionTableData, $$GameSessionTableTableReferences),
    GameSessionTableData,
    PrefetchHooks Function(
        {bool playersTableRefs,
        bool playerScoresTableRefs,
        bool roundsTableRefs})> {
  $$GameSessionTableTableTableManager(
      _$AppDatabase db, $GameSessionTableTable table)
      : super(TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$GameSessionTableTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$GameSessionTableTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$GameSessionTableTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback: ({
            Value<String> id = const Value.absent(),
            Value<DateTime> createdAt = const Value.absent(),
            Value<String> gameTitle = const Value.absent(),
            Value<int> pointLimit = const Value.absent(),
            Value<int> caboPenalty = const Value.absent(),
            Value<bool> isPointsLimitEnabled = const Value.absent(),
            Value<bool> isGameFinished = const Value.absent(),
            Value<String?> winner = const Value.absent(),
            Value<int> roundNumber = const Value.absent(),
            Value<int> rowid = const Value.absent(),
          }) =>
              GameSessionTableCompanion(
            id: id,
            createdAt: createdAt,
            gameTitle: gameTitle,
            pointLimit: pointLimit,
            caboPenalty: caboPenalty,
            isPointsLimitEnabled: isPointsLimitEnabled,
            isGameFinished: isGameFinished,
            winner: winner,
            roundNumber: roundNumber,
            rowid: rowid,
          ),
          createCompanionCallback: ({
            required String id,
            required DateTime createdAt,
            required String gameTitle,
            required int pointLimit,
            required int caboPenalty,
            required bool isPointsLimitEnabled,
            required bool isGameFinished,
            Value<String?> winner = const Value.absent(),
            required int roundNumber,
            Value<int> rowid = const Value.absent(),
          }) =>
              GameSessionTableCompanion.insert(
            id: id,
            createdAt: createdAt,
            gameTitle: gameTitle,
            pointLimit: pointLimit,
            caboPenalty: caboPenalty,
            isPointsLimitEnabled: isPointsLimitEnabled,
            isGameFinished: isGameFinished,
            winner: winner,
            roundNumber: roundNumber,
            rowid: rowid,
          ),
          withReferenceMapper: (p0) => p0
              .map((e) => (
                    e.readTable(table),
                    $$GameSessionTableTableReferences(db, table, e)
                  ))
              .toList(),
          prefetchHooksCallback: (
              {playersTableRefs = false,
              playerScoresTableRefs = false,
              roundsTableRefs = false}) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [
                if (playersTableRefs) db.playersTable,
                if (playerScoresTableRefs) db.playerScoresTable,
                if (roundsTableRefs) db.roundsTable
              ],
              addJoins: null,
              getPrefetchedDataCallback: (items) async {
                return [
                  if (playersTableRefs)
                    await $_getPrefetchedData<GameSessionTableData,
                            $GameSessionTableTable, PlayersTableData>(
                        currentTable: table,
                        referencedTable: $$GameSessionTableTableReferences
                            ._playersTableRefsTable(db),
                        managerFromTypedResult: (p0) =>
                            $$GameSessionTableTableReferences(db, table, p0)
                                .playersTableRefs,
                        referencedItemsForCurrentItem:
                            (item, referencedItems) =>
                                referencedItems.where((e) => e.id == item.id),
                        typedResults: items),
                  if (playerScoresTableRefs)
                    await $_getPrefetchedData<GameSessionTableData,
                            $GameSessionTableTable, PlayerScoresTableData>(
                        currentTable: table,
                        referencedTable: $$GameSessionTableTableReferences
                            ._playerScoresTableRefsTable(db),
                        managerFromTypedResult: (p0) =>
                            $$GameSessionTableTableReferences(db, table, p0)
                                .playerScoresTableRefs,
                        referencedItemsForCurrentItem: (item,
                                referencedItems) =>
                            referencedItems.where((e) => e.roundId == item.id),
                        typedResults: items),
                  if (roundsTableRefs)
                    await $_getPrefetchedData<GameSessionTableData,
                            $GameSessionTableTable, RoundsTableData>(
                        currentTable: table,
                        referencedTable: $$GameSessionTableTableReferences
                            ._roundsTableRefsTable(db),
                        managerFromTypedResult: (p0) =>
                            $$GameSessionTableTableReferences(db, table, p0)
                                .roundsTableRefs,
                        referencedItemsForCurrentItem: (item,
                                referencedItems) =>
                            referencedItems.where((e) => e.gameId == item.id),
                        typedResults: items)
                ];
              },
            );
          },
        ));
}

typedef $$GameSessionTableTableProcessedTableManager = ProcessedTableManager<
    _$AppDatabase,
    $GameSessionTableTable,
    GameSessionTableData,
    $$GameSessionTableTableFilterComposer,
    $$GameSessionTableTableOrderingComposer,
    $$GameSessionTableTableAnnotationComposer,
    $$GameSessionTableTableCreateCompanionBuilder,
    $$GameSessionTableTableUpdateCompanionBuilder,
    (GameSessionTableData, $$GameSessionTableTableReferences),
    GameSessionTableData,
    PrefetchHooks Function(
        {bool playersTableRefs,
        bool playerScoresTableRefs,
        bool roundsTableRefs})>;
typedef $$PlayersTableTableCreateCompanionBuilder = PlayersTableCompanion
    Function({
  required String id,
  required String name,
  Value<int> rowid,
});
typedef $$PlayersTableTableUpdateCompanionBuilder = PlayersTableCompanion
    Function({
  Value<String> id,
  Value<String> name,
  Value<int> rowid,
});

final class $$PlayersTableTableReferences extends BaseReferences<_$AppDatabase,
    $PlayersTableTable, PlayersTableData> {
  $$PlayersTableTableReferences(super.$_db, super.$_table, super.$_typedResult);

  static $GameSessionTableTable _idTable(_$AppDatabase db) =>
      db.gameSessionTable.createAlias(
          $_aliasNameGenerator(db.playersTable.playerId, db.gameSessionTable.id));

  $$GameSessionTableTableProcessedTableManager get id {
    final $_column = $_itemColumn<String>('id')!;

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

  static MultiTypedResultKey<$PlayerScoresTableTable,
      List<PlayerScoresTableData>> _playerScoresTableRefsTable(
          _$AppDatabase db) =>
      MultiTypedResultKey.fromTable(db.playerScoresTable,
          aliasName: $_aliasNameGenerator(
              db.playersTable.name, db.playerScoresTable.playerName));

  $$PlayerScoresTableTableProcessedTableManager get playerScoresTableRefs {
    final manager = $$PlayerScoresTableTableTableManager(
            $_db, $_db.playerScoresTable)
        .filter(
            (f) => f.playerName.name.sqlEquals($_itemColumn<String>('name')!));

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

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

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

  Expression<bool> playerScoresTableRefs(
      Expression<bool> Function($$PlayerScoresTableTableFilterComposer f) f) {
    final $$PlayerScoresTableTableFilterComposer composer = $composerBuilder(
        composer: this,
        getCurrentColumn: (t) => t.name,
        referencedTable: $db.playerScoresTable,
        getReferencedColumn: (t) => t.playerName,
        builder: (joinBuilder,
                {$addJoinBuilderToRootComposer,
                $removeJoinBuilderFromRootComposer}) =>
            $$PlayerScoresTableTableFilterComposer(
              $db: $db,
              $table: $db.playerScoresTable,
              $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
              joinBuilder: joinBuilder,
              $removeJoinBuilderFromRootComposer:
                  $removeJoinBuilderFromRootComposer,
            ));
    return f(composer);
  }
}

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

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

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

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

  Expression<T> playerScoresTableRefs<T extends Object>(
      Expression<T> Function($$PlayerScoresTableTableAnnotationComposer a) f) {
    final $$PlayerScoresTableTableAnnotationComposer composer =
        $composerBuilder(
            composer: this,
            getCurrentColumn: (t) => t.name,
            referencedTable: $db.playerScoresTable,
            getReferencedColumn: (t) => t.playerName,
            builder: (joinBuilder,
                    {$addJoinBuilderToRootComposer,
                    $removeJoinBuilderFromRootComposer}) =>
                $$PlayerScoresTableTableAnnotationComposer(
                  $db: $db,
                  $table: $db.playerScoresTable,
                  $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
                  joinBuilder: joinBuilder,
                  $removeJoinBuilderFromRootComposer:
                      $removeJoinBuilderFromRootComposer,
                ));
    return f(composer);
  }
}

class $$PlayersTableTableTableManager extends RootTableManager<
    _$AppDatabase,
    $PlayersTableTable,
    PlayersTableData,
    $$PlayersTableTableFilterComposer,
    $$PlayersTableTableOrderingComposer,
    $$PlayersTableTableAnnotationComposer,
    $$PlayersTableTableCreateCompanionBuilder,
    $$PlayersTableTableUpdateCompanionBuilder,
    (PlayersTableData, $$PlayersTableTableReferences),
    PlayersTableData,
    PrefetchHooks Function({bool id, bool playerScoresTableRefs})> {
  $$PlayersTableTableTableManager(_$AppDatabase db, $PlayersTableTable table)
      : super(TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$PlayersTableTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$PlayersTableTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$PlayersTableTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback: ({
            Value<String> id = const Value.absent(),
            Value<String> name = const Value.absent(),
            Value<int> rowid = const Value.absent(),
          }) =>
              PlayersTableCompanion(
            id: id,
            name: name,
            rowid: rowid,
          ),
          createCompanionCallback: ({
            required String id,
            required String name,
            Value<int> rowid = const Value.absent(),
          }) =>
              PlayersTableCompanion.insert(
            id: id,
            name: name,
            rowid: rowid,
          ),
          withReferenceMapper: (p0) => p0
              .map((e) => (
                    e.readTable(table),
                    $$PlayersTableTableReferences(db, table, e)
                  ))
              .toList(),
          prefetchHooksCallback: ({id = false, playerScoresTableRefs = false}) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [
                if (playerScoresTableRefs) db.playerScoresTable
              ],
              addJoins: <
                  T extends TableManagerState<
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic>>(state) {
                if (id) {
                  state = state.withJoin(
                    currentTable: table,
                    currentColumn: table.playerId,
                    referencedTable: $$PlayersTableTableReferences._idTable(db),
                    referencedColumn:
                        $$PlayersTableTableReferences._idTable(db).id,
                  ) as T;
                }

                return state;
              },
              getPrefetchedDataCallback: (items) async {
                return [
                  if (playerScoresTableRefs)
                    await $_getPrefetchedData<PlayersTableData,
                            $PlayersTableTable, PlayerScoresTableData>(
                        currentTable: table,
                        referencedTable: $$PlayersTableTableReferences
                            ._playerScoresTableRefsTable(db),
                        managerFromTypedResult: (p0) =>
                            $$PlayersTableTableReferences(db, table, p0)
                                .playerScoresTableRefs,
                        referencedItemsForCurrentItem:
                            (item, referencedItems) => referencedItems
                                .where((e) => e.playerName == item.name),
                        typedResults: items)
                ];
              },
            );
          },
        ));
}

typedef $$PlayersTableTableProcessedTableManager = ProcessedTableManager<
    _$AppDatabase,
    $PlayersTableTable,
    PlayersTableData,
    $$PlayersTableTableFilterComposer,
    $$PlayersTableTableOrderingComposer,
    $$PlayersTableTableAnnotationComposer,
    $$PlayersTableTableCreateCompanionBuilder,
    $$PlayersTableTableUpdateCompanionBuilder,
    (PlayersTableData, $$PlayersTableTableReferences),
    PlayersTableData,
    PrefetchHooks Function({bool id, bool playerScoresTableRefs})>;
typedef $$PlayerScoresTableTableCreateCompanionBuilder
    = PlayerScoresTableCompanion Function({
  required String roundId,
  required String playerName,
  required int totalScore,
  Value<int> rowid,
});
typedef $$PlayerScoresTableTableUpdateCompanionBuilder
    = PlayerScoresTableCompanion Function({
  Value<String> roundId,
  Value<String> playerName,
  Value<int> totalScore,
  Value<int> rowid,
});

final class $$PlayerScoresTableTableReferences extends BaseReferences<
    _$AppDatabase, $PlayerScoresTableTable, PlayerScoresTableData> {
  $$PlayerScoresTableTableReferences(
      super.$_db, super.$_table, super.$_typedResult);

  static $GameSessionTableTable _roundIdTable(_$AppDatabase db) =>
      db.gameSessionTable.createAlias($_aliasNameGenerator(
          db.playerScoresTable.roundId, db.gameSessionTable.id));

  $$GameSessionTableTableProcessedTableManager get roundId {
    final $_column = $_itemColumn<String>('round_id')!;

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

  static $PlayersTableTable _playerNameTable(_$AppDatabase db) =>
      db.playersTable.createAlias($_aliasNameGenerator(
          db.playerScoresTable.playerName, db.playersTable.name));

  $$PlayersTableTableProcessedTableManager get playerName {
    final $_column = $_itemColumn<String>('player_name')!;

    final manager = $$PlayersTableTableTableManager($_db, $_db.playersTable)
        .filter((f) => f.name.sqlEquals($_column));
    final item = $_typedResult.readTableOrNull(_playerNameTable($_db));
    if (item == null) return manager;
    return ProcessedTableManager(
        manager.$state.copyWith(prefetchedData: [item]));
  }
}

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

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

  $$PlayersTableTableFilterComposer get playerName {
    final $$PlayersTableTableFilterComposer composer = $composerBuilder(
        composer: this,
        getCurrentColumn: (t) => t.playerName,
        referencedTable: $db.playersTable,
        getReferencedColumn: (t) => t.name,
        builder: (joinBuilder,
                {$addJoinBuilderToRootComposer,
                $removeJoinBuilderFromRootComposer}) =>
            $$PlayersTableTableFilterComposer(
              $db: $db,
              $table: $db.playersTable,
              $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
              joinBuilder: joinBuilder,
              $removeJoinBuilderFromRootComposer:
                  $removeJoinBuilderFromRootComposer,
            ));
    return composer;
  }
}

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

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

  $$PlayersTableTableOrderingComposer get playerName {
    final $$PlayersTableTableOrderingComposer composer = $composerBuilder(
        composer: this,
        getCurrentColumn: (t) => t.playerName,
        referencedTable: $db.playersTable,
        getReferencedColumn: (t) => t.name,
        builder: (joinBuilder,
                {$addJoinBuilderToRootComposer,
                $removeJoinBuilderFromRootComposer}) =>
            $$PlayersTableTableOrderingComposer(
              $db: $db,
              $table: $db.playersTable,
              $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
              joinBuilder: joinBuilder,
              $removeJoinBuilderFromRootComposer:
                  $removeJoinBuilderFromRootComposer,
            ));
    return composer;
  }
}

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

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

  $$PlayersTableTableAnnotationComposer get playerName {
    final $$PlayersTableTableAnnotationComposer composer = $composerBuilder(
        composer: this,
        getCurrentColumn: (t) => t.playerName,
        referencedTable: $db.playersTable,
        getReferencedColumn: (t) => t.name,
        builder: (joinBuilder,
                {$addJoinBuilderToRootComposer,
                $removeJoinBuilderFromRootComposer}) =>
            $$PlayersTableTableAnnotationComposer(
              $db: $db,
              $table: $db.playersTable,
              $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
              joinBuilder: joinBuilder,
              $removeJoinBuilderFromRootComposer:
                  $removeJoinBuilderFromRootComposer,
            ));
    return composer;
  }
}

class $$PlayerScoresTableTableTableManager extends RootTableManager<
    _$AppDatabase,
    $PlayerScoresTableTable,
    PlayerScoresTableData,
    $$PlayerScoresTableTableFilterComposer,
    $$PlayerScoresTableTableOrderingComposer,
    $$PlayerScoresTableTableAnnotationComposer,
    $$PlayerScoresTableTableCreateCompanionBuilder,
    $$PlayerScoresTableTableUpdateCompanionBuilder,
    (PlayerScoresTableData, $$PlayerScoresTableTableReferences),
    PlayerScoresTableData,
    PrefetchHooks Function({bool roundId, bool playerName})> {
  $$PlayerScoresTableTableTableManager(
      _$AppDatabase db, $PlayerScoresTableTable table)
      : super(TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$PlayerScoresTableTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$PlayerScoresTableTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$PlayerScoresTableTableAnnotationComposer(
                  $db: db, $table: table),
          updateCompanionCallback: ({
            Value<String> roundId = const Value.absent(),
            Value<String> playerName = const Value.absent(),
            Value<int> totalScore = const Value.absent(),
            Value<int> rowid = const Value.absent(),
          }) =>
              PlayerScoresTableCompanion(
            roundId: roundId,
            playerName: playerName,
            totalScore: totalScore,
            rowid: rowid,
          ),
          createCompanionCallback: ({
            required String roundId,
            required String playerName,
            required int totalScore,
            Value<int> rowid = const Value.absent(),
          }) =>
              PlayerScoresTableCompanion.insert(
            roundId: roundId,
            playerName: playerName,
            totalScore: totalScore,
            rowid: rowid,
          ),
          withReferenceMapper: (p0) => p0
              .map((e) => (
                    e.readTable(table),
                    $$PlayerScoresTableTableReferences(db, table, e)
                  ))
              .toList(),
          prefetchHooksCallback: ({roundId = false, playerName = false}) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [],
              addJoins: <
                  T extends TableManagerState<
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic>>(state) {
                if (roundId) {
                  state = state.withJoin(
                    currentTable: table,
                    currentColumn: table.roundId,
                    referencedTable:
                        $$PlayerScoresTableTableReferences._roundIdTable(db),
                    referencedColumn:
                        $$PlayerScoresTableTableReferences._roundIdTable(db).id,
                  ) as T;
                }
                if (playerName) {
                  state = state.withJoin(
                    currentTable: table,
                    currentColumn: table.playerName,
                    referencedTable:
                        $$PlayerScoresTableTableReferences._playerNameTable(db),
                    referencedColumn: $$PlayerScoresTableTableReferences
                        ._playerNameTable(db)
                        .name,
                  ) as T;
                }

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

typedef $$PlayerScoresTableTableProcessedTableManager = ProcessedTableManager<
    _$AppDatabase,
    $PlayerScoresTableTable,
    PlayerScoresTableData,
    $$PlayerScoresTableTableFilterComposer,
    $$PlayerScoresTableTableOrderingComposer,
    $$PlayerScoresTableTableAnnotationComposer,
    $$PlayerScoresTableTableCreateCompanionBuilder,
    $$PlayerScoresTableTableUpdateCompanionBuilder,
    (PlayerScoresTableData, $$PlayerScoresTableTableReferences),
    PlayerScoresTableData,
    PrefetchHooks Function({bool roundId, bool playerName})>;
typedef $$RoundsTableTableCreateCompanionBuilder = RoundsTableCompanion
    Function({
  required String id,
  required String gameId,
  required int roundNumber,
  Value<String?> kamikazePlayer,
  Value<int> rowid,
});
typedef $$RoundsTableTableUpdateCompanionBuilder = RoundsTableCompanion
    Function({
  Value<String> id,
  Value<String> gameId,
  Value<int> roundNumber,
  Value<String?> kamikazePlayer,
  Value<int> rowid,
});

final class $$RoundsTableTableReferences
    extends BaseReferences<_$AppDatabase, $RoundsTableTable, RoundsTableData> {
  $$RoundsTableTableReferences(super.$_db, super.$_table, super.$_typedResult);

  static $GameSessionTableTable _gameIdTable(_$AppDatabase db) =>
      db.gameSessionTable.createAlias(
          $_aliasNameGenerator(db.roundsTable.gameId, db.gameSessionTable.id));

  $$GameSessionTableTableProcessedTableManager get gameId {
    final $_column = $_itemColumn<String>('game_id')!;

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

  static MultiTypedResultKey<$RoundScoresTableTable, List<RoundScoresTableData>>
      _roundScoresTableRefsTable(_$AppDatabase db) =>
          MultiTypedResultKey.fromTable(db.roundScoresTable,
              aliasName: $_aliasNameGenerator(
                  db.roundsTable.id, db.roundScoresTable.roundId));

  $$RoundScoresTableTableProcessedTableManager get roundScoresTableRefs {
    final manager =
        $$RoundScoresTableTableTableManager($_db, $_db.roundScoresTable)
            .filter((f) => f.roundId.id.sqlEquals($_itemColumn<String>('id')!));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class $$RoundsTableTableTableManager extends RootTableManager<
    _$AppDatabase,
    $RoundsTableTable,
    RoundsTableData,
    $$RoundsTableTableFilterComposer,
    $$RoundsTableTableOrderingComposer,
    $$RoundsTableTableAnnotationComposer,
    $$RoundsTableTableCreateCompanionBuilder,
    $$RoundsTableTableUpdateCompanionBuilder,
    (RoundsTableData, $$RoundsTableTableReferences),
    RoundsTableData,
    PrefetchHooks Function({bool gameId, bool roundScoresTableRefs})> {
  $$RoundsTableTableTableManager(_$AppDatabase db, $RoundsTableTable table)
      : super(TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$RoundsTableTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$RoundsTableTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$RoundsTableTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback: ({
            Value<String> id = const Value.absent(),
            Value<String> gameId = const Value.absent(),
            Value<int> roundNumber = const Value.absent(),
            Value<String?> kamikazePlayer = const Value.absent(),
            Value<int> rowid = const Value.absent(),
          }) =>
              RoundsTableCompanion(
            id: id,
            gameId: gameId,
            roundNumber: roundNumber,
            kamikazePlayer: kamikazePlayer,
            rowid: rowid,
          ),
          createCompanionCallback: ({
            required String id,
            required String gameId,
            required int roundNumber,
            Value<String?> kamikazePlayer = const Value.absent(),
            Value<int> rowid = const Value.absent(),
          }) =>
              RoundsTableCompanion.insert(
            id: id,
            gameId: gameId,
            roundNumber: roundNumber,
            kamikazePlayer: kamikazePlayer,
            rowid: rowid,
          ),
          withReferenceMapper: (p0) => p0
              .map((e) => (
                    e.readTable(table),
                    $$RoundsTableTableReferences(db, table, e)
                  ))
              .toList(),
          prefetchHooksCallback: (
              {gameId = false, roundScoresTableRefs = false}) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [
                if (roundScoresTableRefs) db.roundScoresTable
              ],
              addJoins: <
                  T extends TableManagerState<
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic>>(state) {
                if (gameId) {
                  state = state.withJoin(
                    currentTable: table,
                    currentColumn: table.gameId,
                    referencedTable:
                        $$RoundsTableTableReferences._gameIdTable(db),
                    referencedColumn:
                        $$RoundsTableTableReferences._gameIdTable(db).id,
                  ) as T;
                }

                return state;
              },
              getPrefetchedDataCallback: (items) async {
                return [
                  if (roundScoresTableRefs)
                    await $_getPrefetchedData<RoundsTableData,
                            $RoundsTableTable, RoundScoresTableData>(
                        currentTable: table,
                        referencedTable: $$RoundsTableTableReferences
                            ._roundScoresTableRefsTable(db),
                        managerFromTypedResult: (p0) =>
                            $$RoundsTableTableReferences(db, table, p0)
                                .roundScoresTableRefs,
                        referencedItemsForCurrentItem: (item,
                                referencedItems) =>
                            referencedItems.where((e) => e.roundId == item.id),
                        typedResults: items)
                ];
              },
            );
          },
        ));
}

typedef $$RoundsTableTableProcessedTableManager = ProcessedTableManager<
    _$AppDatabase,
    $RoundsTableTable,
    RoundsTableData,
    $$RoundsTableTableFilterComposer,
    $$RoundsTableTableOrderingComposer,
    $$RoundsTableTableAnnotationComposer,
    $$RoundsTableTableCreateCompanionBuilder,
    $$RoundsTableTableUpdateCompanionBuilder,
    (RoundsTableData, $$RoundsTableTableReferences),
    RoundsTableData,
    PrefetchHooks Function({bool gameId, bool roundScoresTableRefs})>;
typedef $$RoundScoresTableTableCreateCompanionBuilder
    = RoundScoresTableCompanion Function({
  required String roundId,
  required String playerName,
  required int score,
  required int scoreUpdate,
  Value<int> rowid,
});
typedef $$RoundScoresTableTableUpdateCompanionBuilder
    = RoundScoresTableCompanion Function({
  Value<String> roundId,
  Value<String> playerName,
  Value<int> score,
  Value<int> scoreUpdate,
  Value<int> rowid,
});

final class $$RoundScoresTableTableReferences extends BaseReferences<
    _$AppDatabase, $RoundScoresTableTable, RoundScoresTableData> {
  $$RoundScoresTableTableReferences(
      super.$_db, super.$_table, super.$_typedResult);

  static $RoundsTableTable _roundIdTable(_$AppDatabase db) =>
      db.roundsTable.createAlias(
          $_aliasNameGenerator(db.roundScoresTable.roundId, db.roundsTable.id));

  $$RoundsTableTableProcessedTableManager get roundId {
    final $_column = $_itemColumn<String>('round_id')!;

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

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

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

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

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

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

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

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

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

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

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

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

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

class $$RoundScoresTableTableTableManager extends RootTableManager<
    _$AppDatabase,
    $RoundScoresTableTable,
    RoundScoresTableData,
    $$RoundScoresTableTableFilterComposer,
    $$RoundScoresTableTableOrderingComposer,
    $$RoundScoresTableTableAnnotationComposer,
    $$RoundScoresTableTableCreateCompanionBuilder,
    $$RoundScoresTableTableUpdateCompanionBuilder,
    (RoundScoresTableData, $$RoundScoresTableTableReferences),
    RoundScoresTableData,
    PrefetchHooks Function({bool roundId})> {
  $$RoundScoresTableTableTableManager(
      _$AppDatabase db, $RoundScoresTableTable table)
      : super(TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$RoundScoresTableTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$RoundScoresTableTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$RoundScoresTableTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback: ({
            Value<String> roundId = const Value.absent(),
            Value<String> playerName = const Value.absent(),
            Value<int> score = const Value.absent(),
            Value<int> scoreUpdate = const Value.absent(),
            Value<int> rowid = const Value.absent(),
          }) =>
              RoundScoresTableCompanion(
            roundId: roundId,
            playerName: playerName,
            score: score,
            scoreUpdate: scoreUpdate,
            rowid: rowid,
          ),
          createCompanionCallback: ({
            required String roundId,
            required String playerName,
            required int score,
            required int scoreUpdate,
            Value<int> rowid = const Value.absent(),
          }) =>
              RoundScoresTableCompanion.insert(
            roundId: roundId,
            playerName: playerName,
            score: score,
            scoreUpdate: scoreUpdate,
            rowid: rowid,
          ),
          withReferenceMapper: (p0) => p0
              .map((e) => (
                    e.readTable(table),
                    $$RoundScoresTableTableReferences(db, table, e)
                  ))
              .toList(),
          prefetchHooksCallback: ({roundId = false}) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [],
              addJoins: <
                  T extends TableManagerState<
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic>>(state) {
                if (roundId) {
                  state = state.withJoin(
                    currentTable: table,
                    currentColumn: table.roundId,
                    referencedTable:
                        $$RoundScoresTableTableReferences._roundIdTable(db),
                    referencedColumn:
                        $$RoundScoresTableTableReferences._roundIdTable(db).id,
                  ) as T;
                }

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

typedef $$RoundScoresTableTableProcessedTableManager = ProcessedTableManager<
    _$AppDatabase,
    $RoundScoresTableTable,
    RoundScoresTableData,
    $$RoundScoresTableTableFilterComposer,
    $$RoundScoresTableTableOrderingComposer,
    $$RoundScoresTableTableAnnotationComposer,
    $$RoundScoresTableTableCreateCompanionBuilder,
    $$RoundScoresTableTableUpdateCompanionBuilder,
    (RoundScoresTableData, $$RoundScoresTableTableReferences),
    RoundScoresTableData,
    PrefetchHooks Function({bool roundId})>;

class $AppDatabaseManager {
  final _$AppDatabase _db;
  $AppDatabaseManager(this._db);
  $$GameSessionTableTableTableManager get gameSessionTable =>
      $$GameSessionTableTableTableManager(_db, _db.gameSessionTable);
  $$PlayersTableTableTableManager get playersTable =>
      $$PlayersTableTableTableManager(_db, _db.playersTable);
  $$PlayerScoresTableTableTableManager get playerScoresTable =>
      $$PlayerScoresTableTableTableManager(_db, _db.playerScoresTable);
  $$RoundsTableTableTableManager get roundsTable =>
      $$RoundsTableTableTableManager(_db, _db.roundsTable);
  $$RoundScoresTableTableTableManager get roundScoresTable =>
      $$RoundScoresTableTableTableManager(_db, _db.roundScoresTable);
}