// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'database.dart';

// ignore_for_file: type=lint
class $HistoryItemsTable extends HistoryItems
    with TableInfo<$HistoryItemsTable, HistoryItem> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $HistoryItemsTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<int> id = GeneratedColumn<int>(
    'id',
    aliasedName,
    false,
    hasAutoIncrement: true,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'PRIMARY KEY AUTOINCREMENT',
    ),
  );
  static const VerificationMeta _urlMeta = const VerificationMeta('url');
  @override
  late final GeneratedColumn<String> url = GeneratedColumn<String>(
    'url',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _titleMeta = const VerificationMeta('title');
  @override
  late final GeneratedColumn<String> title = GeneratedColumn<String>(
    'title',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
  );
  static const VerificationMeta _visitedAtMeta = const VerificationMeta(
    'visitedAt',
  );
  @override
  late final GeneratedColumn<DateTime> visitedAt = GeneratedColumn<DateTime>(
    'visited_at',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: false,
    defaultValue: currentDateAndTime,
  );
  @override
  List<GeneratedColumn> get $columns => [id, url, title, visitedAt];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'history_items';
  @override
  VerificationContext validateIntegrity(
    Insertable<HistoryItem> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    }
    if (data.containsKey('url')) {
      context.handle(
        _urlMeta,
        url.isAcceptableOrUnknown(data['url']!, _urlMeta),
      );
    } else if (isInserting) {
      context.missing(_urlMeta);
    }
    if (data.containsKey('title')) {
      context.handle(
        _titleMeta,
        title.isAcceptableOrUnknown(data['title']!, _titleMeta),
      );
    }
    if (data.containsKey('visited_at')) {
      context.handle(
        _visitedAtMeta,
        visitedAt.isAcceptableOrUnknown(data['visited_at']!, _visitedAtMeta),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  HistoryItem map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return HistoryItem(
      id: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}id'],
      )!,
      url: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}url'],
      )!,
      title: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}title'],
      ),
      visitedAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}visited_at'],
      )!,
    );
  }

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

class HistoryItem extends DataClass implements Insertable<HistoryItem> {
  final int id;
  final String url;
  final String? title;
  final DateTime visitedAt;
  const HistoryItem({
    required this.id,
    required this.url,
    this.title,
    required this.visitedAt,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<int>(id);
    map['url'] = Variable<String>(url);
    if (!nullToAbsent || title != null) {
      map['title'] = Variable<String>(title);
    }
    map['visited_at'] = Variable<DateTime>(visitedAt);
    return map;
  }

  HistoryItemsCompanion toCompanion(bool nullToAbsent) {
    return HistoryItemsCompanion(
      id: Value(id),
      url: Value(url),
      title: title == null && nullToAbsent
          ? const Value.absent()
          : Value(title),
      visitedAt: Value(visitedAt),
    );
  }

  factory HistoryItem.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return HistoryItem(
      id: serializer.fromJson<int>(json['id']),
      url: serializer.fromJson<String>(json['url']),
      title: serializer.fromJson<String?>(json['title']),
      visitedAt: serializer.fromJson<DateTime>(json['visitedAt']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'id': serializer.toJson<int>(id),
      'url': serializer.toJson<String>(url),
      'title': serializer.toJson<String?>(title),
      'visitedAt': serializer.toJson<DateTime>(visitedAt),
    };
  }

  HistoryItem copyWith({
    int? id,
    String? url,
    Value<String?> title = const Value.absent(),
    DateTime? visitedAt,
  }) => HistoryItem(
    id: id ?? this.id,
    url: url ?? this.url,
    title: title.present ? title.value : this.title,
    visitedAt: visitedAt ?? this.visitedAt,
  );
  HistoryItem copyWithCompanion(HistoryItemsCompanion data) {
    return HistoryItem(
      id: data.id.present ? data.id.value : this.id,
      url: data.url.present ? data.url.value : this.url,
      title: data.title.present ? data.title.value : this.title,
      visitedAt: data.visitedAt.present ? data.visitedAt.value : this.visitedAt,
    );
  }

  @override
  String toString() {
    return (StringBuffer('HistoryItem(')
          ..write('id: $id, ')
          ..write('url: $url, ')
          ..write('title: $title, ')
          ..write('visitedAt: $visitedAt')
          ..write(')'))
        .toString();
  }

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

class HistoryItemsCompanion extends UpdateCompanion<HistoryItem> {
  final Value<int> id;
  final Value<String> url;
  final Value<String?> title;
  final Value<DateTime> visitedAt;
  const HistoryItemsCompanion({
    this.id = const Value.absent(),
    this.url = const Value.absent(),
    this.title = const Value.absent(),
    this.visitedAt = const Value.absent(),
  });
  HistoryItemsCompanion.insert({
    this.id = const Value.absent(),
    required String url,
    this.title = const Value.absent(),
    this.visitedAt = const Value.absent(),
  }) : url = Value(url);
  static Insertable<HistoryItem> custom({
    Expression<int>? id,
    Expression<String>? url,
    Expression<String>? title,
    Expression<DateTime>? visitedAt,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (url != null) 'url': url,
      if (title != null) 'title': title,
      if (visitedAt != null) 'visited_at': visitedAt,
    });
  }

  HistoryItemsCompanion copyWith({
    Value<int>? id,
    Value<String>? url,
    Value<String?>? title,
    Value<DateTime>? visitedAt,
  }) {
    return HistoryItemsCompanion(
      id: id ?? this.id,
      url: url ?? this.url,
      title: title ?? this.title,
      visitedAt: visitedAt ?? this.visitedAt,
    );
  }

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

  @override
  String toString() {
    return (StringBuffer('HistoryItemsCompanion(')
          ..write('id: $id, ')
          ..write('url: $url, ')
          ..write('title: $title, ')
          ..write('visitedAt: $visitedAt')
          ..write(')'))
        .toString();
  }
}

class $BookmarksTable extends Bookmarks
    with TableInfo<$BookmarksTable, Bookmark> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $BookmarksTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _urlMeta = const VerificationMeta('url');
  @override
  late final GeneratedColumn<String> url = GeneratedColumn<String>(
    'url',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _titleMeta = const VerificationMeta('title');
  @override
  late final GeneratedColumn<String> title = GeneratedColumn<String>(
    'title',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
  );
  static const VerificationMeta _createdAtMeta = const VerificationMeta(
    'createdAt',
  );
  @override
  late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
    'created_at',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: false,
    defaultValue: currentDateAndTime,
  );
  @override
  List<GeneratedColumn> get $columns => [url, title, createdAt];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'bookmarks';
  @override
  VerificationContext validateIntegrity(
    Insertable<Bookmark> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('url')) {
      context.handle(
        _urlMeta,
        url.isAcceptableOrUnknown(data['url']!, _urlMeta),
      );
    } else if (isInserting) {
      context.missing(_urlMeta);
    }
    if (data.containsKey('title')) {
      context.handle(
        _titleMeta,
        title.isAcceptableOrUnknown(data['title']!, _titleMeta),
      );
    }
    if (data.containsKey('created_at')) {
      context.handle(
        _createdAtMeta,
        createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
      );
    }
    return context;
  }

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

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

class Bookmark extends DataClass implements Insertable<Bookmark> {
  final String url;
  final String? title;
  final DateTime createdAt;
  const Bookmark({required this.url, this.title, required this.createdAt});
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['url'] = Variable<String>(url);
    if (!nullToAbsent || title != null) {
      map['title'] = Variable<String>(title);
    }
    map['created_at'] = Variable<DateTime>(createdAt);
    return map;
  }

  BookmarksCompanion toCompanion(bool nullToAbsent) {
    return BookmarksCompanion(
      url: Value(url),
      title: title == null && nullToAbsent
          ? const Value.absent()
          : Value(title),
      createdAt: Value(createdAt),
    );
  }

  factory Bookmark.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return Bookmark(
      url: serializer.fromJson<String>(json['url']),
      title: serializer.fromJson<String?>(json['title']),
      createdAt: serializer.fromJson<DateTime>(json['createdAt']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'url': serializer.toJson<String>(url),
      'title': serializer.toJson<String?>(title),
      'createdAt': serializer.toJson<DateTime>(createdAt),
    };
  }

  Bookmark copyWith({
    String? url,
    Value<String?> title = const Value.absent(),
    DateTime? createdAt,
  }) => Bookmark(
    url: url ?? this.url,
    title: title.present ? title.value : this.title,
    createdAt: createdAt ?? this.createdAt,
  );
  Bookmark copyWithCompanion(BookmarksCompanion data) {
    return Bookmark(
      url: data.url.present ? data.url.value : this.url,
      title: data.title.present ? data.title.value : this.title,
      createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
    );
  }

  @override
  String toString() {
    return (StringBuffer('Bookmark(')
          ..write('url: $url, ')
          ..write('title: $title, ')
          ..write('createdAt: $createdAt')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(url, title, createdAt);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is Bookmark &&
          other.url == this.url &&
          other.title == this.title &&
          other.createdAt == this.createdAt);
}

class BookmarksCompanion extends UpdateCompanion<Bookmark> {
  final Value<String> url;
  final Value<String?> title;
  final Value<DateTime> createdAt;
  final Value<int> rowid;
  const BookmarksCompanion({
    this.url = const Value.absent(),
    this.title = const Value.absent(),
    this.createdAt = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  BookmarksCompanion.insert({
    required String url,
    this.title = const Value.absent(),
    this.createdAt = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : url = Value(url);
  static Insertable<Bookmark> custom({
    Expression<String>? url,
    Expression<String>? title,
    Expression<DateTime>? createdAt,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (url != null) 'url': url,
      if (title != null) 'title': title,
      if (createdAt != null) 'created_at': createdAt,
      if (rowid != null) 'rowid': rowid,
    });
  }

  BookmarksCompanion copyWith({
    Value<String>? url,
    Value<String?>? title,
    Value<DateTime>? createdAt,
    Value<int>? rowid,
  }) {
    return BookmarksCompanion(
      url: url ?? this.url,
      title: title ?? this.title,
      createdAt: createdAt ?? this.createdAt,
      rowid: rowid ?? this.rowid,
    );
  }

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

  @override
  String toString() {
    return (StringBuffer('BookmarksCompanion(')
          ..write('url: $url, ')
          ..write('title: $title, ')
          ..write('createdAt: $createdAt, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $SubscriptionsTable extends Subscriptions
    with TableInfo<$SubscriptionsTable, Subscription> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $SubscriptionsTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _urlMeta = const VerificationMeta('url');
  @override
  late final GeneratedColumn<String> url = GeneratedColumn<String>(
    'url',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _titleMeta = const VerificationMeta('title');
  @override
  late final GeneratedColumn<String> title = GeneratedColumn<String>(
    'title',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
  );
  static const VerificationMeta _atomHrefMeta = const VerificationMeta(
    'atomHref',
  );
  @override
  late final GeneratedColumn<String> atomHref = GeneratedColumn<String>(
    'atom_href',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
  );
  static const VerificationMeta _createdAtMeta = const VerificationMeta(
    'createdAt',
  );
  @override
  late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
    'created_at',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: false,
    defaultValue: currentDateAndTime,
  );
  static const VerificationMeta _lastCheckedAtMeta = const VerificationMeta(
    'lastCheckedAt',
  );
  @override
  late final GeneratedColumn<DateTime> lastCheckedAt =
      GeneratedColumn<DateTime>(
        'last_checked_at',
        aliasedName,
        true,
        type: DriftSqlType.dateTime,
        requiredDuringInsert: false,
      );
  @override
  List<GeneratedColumn> get $columns => [
    url,
    title,
    atomHref,
    createdAt,
    lastCheckedAt,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'subscriptions';
  @override
  VerificationContext validateIntegrity(
    Insertable<Subscription> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('url')) {
      context.handle(
        _urlMeta,
        url.isAcceptableOrUnknown(data['url']!, _urlMeta),
      );
    } else if (isInserting) {
      context.missing(_urlMeta);
    }
    if (data.containsKey('title')) {
      context.handle(
        _titleMeta,
        title.isAcceptableOrUnknown(data['title']!, _titleMeta),
      );
    }
    if (data.containsKey('atom_href')) {
      context.handle(
        _atomHrefMeta,
        atomHref.isAcceptableOrUnknown(data['atom_href']!, _atomHrefMeta),
      );
    }
    if (data.containsKey('created_at')) {
      context.handle(
        _createdAtMeta,
        createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
      );
    }
    if (data.containsKey('last_checked_at')) {
      context.handle(
        _lastCheckedAtMeta,
        lastCheckedAt.isAcceptableOrUnknown(
          data['last_checked_at']!,
          _lastCheckedAtMeta,
        ),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {url};
  @override
  Subscription map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return Subscription(
      url: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}url'],
      )!,
      title: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}title'],
      ),
      atomHref: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}atom_href'],
      ),
      createdAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}created_at'],
      )!,
      lastCheckedAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}last_checked_at'],
      ),
    );
  }

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

class Subscription extends DataClass implements Insertable<Subscription> {
  final String url;
  final String? title;

  /// The page's Atom feed, resolved absolute, when it declares one (spec 6.2).
  final String? atomHref;
  final DateTime createdAt;
  final DateTime? lastCheckedAt;
  const Subscription({
    required this.url,
    this.title,
    this.atomHref,
    required this.createdAt,
    this.lastCheckedAt,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['url'] = Variable<String>(url);
    if (!nullToAbsent || title != null) {
      map['title'] = Variable<String>(title);
    }
    if (!nullToAbsent || atomHref != null) {
      map['atom_href'] = Variable<String>(atomHref);
    }
    map['created_at'] = Variable<DateTime>(createdAt);
    if (!nullToAbsent || lastCheckedAt != null) {
      map['last_checked_at'] = Variable<DateTime>(lastCheckedAt);
    }
    return map;
  }

  SubscriptionsCompanion toCompanion(bool nullToAbsent) {
    return SubscriptionsCompanion(
      url: Value(url),
      title: title == null && nullToAbsent
          ? const Value.absent()
          : Value(title),
      atomHref: atomHref == null && nullToAbsent
          ? const Value.absent()
          : Value(atomHref),
      createdAt: Value(createdAt),
      lastCheckedAt: lastCheckedAt == null && nullToAbsent
          ? const Value.absent()
          : Value(lastCheckedAt),
    );
  }

  factory Subscription.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return Subscription(
      url: serializer.fromJson<String>(json['url']),
      title: serializer.fromJson<String?>(json['title']),
      atomHref: serializer.fromJson<String?>(json['atomHref']),
      createdAt: serializer.fromJson<DateTime>(json['createdAt']),
      lastCheckedAt: serializer.fromJson<DateTime?>(json['lastCheckedAt']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'url': serializer.toJson<String>(url),
      'title': serializer.toJson<String?>(title),
      'atomHref': serializer.toJson<String?>(atomHref),
      'createdAt': serializer.toJson<DateTime>(createdAt),
      'lastCheckedAt': serializer.toJson<DateTime?>(lastCheckedAt),
    };
  }

  Subscription copyWith({
    String? url,
    Value<String?> title = const Value.absent(),
    Value<String?> atomHref = const Value.absent(),
    DateTime? createdAt,
    Value<DateTime?> lastCheckedAt = const Value.absent(),
  }) => Subscription(
    url: url ?? this.url,
    title: title.present ? title.value : this.title,
    atomHref: atomHref.present ? atomHref.value : this.atomHref,
    createdAt: createdAt ?? this.createdAt,
    lastCheckedAt: lastCheckedAt.present
        ? lastCheckedAt.value
        : this.lastCheckedAt,
  );
  Subscription copyWithCompanion(SubscriptionsCompanion data) {
    return Subscription(
      url: data.url.present ? data.url.value : this.url,
      title: data.title.present ? data.title.value : this.title,
      atomHref: data.atomHref.present ? data.atomHref.value : this.atomHref,
      createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
      lastCheckedAt: data.lastCheckedAt.present
          ? data.lastCheckedAt.value
          : this.lastCheckedAt,
    );
  }

  @override
  String toString() {
    return (StringBuffer('Subscription(')
          ..write('url: $url, ')
          ..write('title: $title, ')
          ..write('atomHref: $atomHref, ')
          ..write('createdAt: $createdAt, ')
          ..write('lastCheckedAt: $lastCheckedAt')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode =>
      Object.hash(url, title, atomHref, createdAt, lastCheckedAt);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is Subscription &&
          other.url == this.url &&
          other.title == this.title &&
          other.atomHref == this.atomHref &&
          other.createdAt == this.createdAt &&
          other.lastCheckedAt == this.lastCheckedAt);
}

class SubscriptionsCompanion extends UpdateCompanion<Subscription> {
  final Value<String> url;
  final Value<String?> title;
  final Value<String?> atomHref;
  final Value<DateTime> createdAt;
  final Value<DateTime?> lastCheckedAt;
  final Value<int> rowid;
  const SubscriptionsCompanion({
    this.url = const Value.absent(),
    this.title = const Value.absent(),
    this.atomHref = const Value.absent(),
    this.createdAt = const Value.absent(),
    this.lastCheckedAt = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  SubscriptionsCompanion.insert({
    required String url,
    this.title = const Value.absent(),
    this.atomHref = const Value.absent(),
    this.createdAt = const Value.absent(),
    this.lastCheckedAt = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : url = Value(url);
  static Insertable<Subscription> custom({
    Expression<String>? url,
    Expression<String>? title,
    Expression<String>? atomHref,
    Expression<DateTime>? createdAt,
    Expression<DateTime>? lastCheckedAt,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (url != null) 'url': url,
      if (title != null) 'title': title,
      if (atomHref != null) 'atom_href': atomHref,
      if (createdAt != null) 'created_at': createdAt,
      if (lastCheckedAt != null) 'last_checked_at': lastCheckedAt,
      if (rowid != null) 'rowid': rowid,
    });
  }

  SubscriptionsCompanion copyWith({
    Value<String>? url,
    Value<String?>? title,
    Value<String?>? atomHref,
    Value<DateTime>? createdAt,
    Value<DateTime?>? lastCheckedAt,
    Value<int>? rowid,
  }) {
    return SubscriptionsCompanion(
      url: url ?? this.url,
      title: title ?? this.title,
      atomHref: atomHref ?? this.atomHref,
      createdAt: createdAt ?? this.createdAt,
      lastCheckedAt: lastCheckedAt ?? this.lastCheckedAt,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (url.present) {
      map['url'] = Variable<String>(url.value);
    }
    if (title.present) {
      map['title'] = Variable<String>(title.value);
    }
    if (atomHref.present) {
      map['atom_href'] = Variable<String>(atomHref.value);
    }
    if (createdAt.present) {
      map['created_at'] = Variable<DateTime>(createdAt.value);
    }
    if (lastCheckedAt.present) {
      map['last_checked_at'] = Variable<DateTime>(lastCheckedAt.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('SubscriptionsCompanion(')
          ..write('url: $url, ')
          ..write('title: $title, ')
          ..write('atomHref: $atomHref, ')
          ..write('createdAt: $createdAt, ')
          ..write('lastCheckedAt: $lastCheckedAt, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $FeedEntriesTable extends FeedEntries
    with TableInfo<$FeedEntriesTable, FeedEntry> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $FeedEntriesTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _siteUrlMeta = const VerificationMeta(
    'siteUrl',
  );
  @override
  late final GeneratedColumn<String> siteUrl = GeneratedColumn<String>(
    'site_url',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _urlMeta = const VerificationMeta('url');
  @override
  late final GeneratedColumn<String> url = GeneratedColumn<String>(
    'url',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _titleMeta = const VerificationMeta('title');
  @override
  late final GeneratedColumn<String> title = GeneratedColumn<String>(
    'title',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _dateMeta = const VerificationMeta('date');
  @override
  late final GeneratedColumn<DateTime> date = GeneratedColumn<DateTime>(
    'date',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _foundAtMeta = const VerificationMeta(
    'foundAt',
  );
  @override
  late final GeneratedColumn<DateTime> foundAt = GeneratedColumn<DateTime>(
    'found_at',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: false,
    defaultValue: currentDateAndTime,
  );
  static const VerificationMeta _readAtMeta = const VerificationMeta('readAt');
  @override
  late final GeneratedColumn<DateTime> readAt = GeneratedColumn<DateTime>(
    'read_at',
    aliasedName,
    true,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: false,
  );
  @override
  List<GeneratedColumn> get $columns => [
    siteUrl,
    url,
    title,
    date,
    foundAt,
    readAt,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'feed_entries';
  @override
  VerificationContext validateIntegrity(
    Insertable<FeedEntry> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('site_url')) {
      context.handle(
        _siteUrlMeta,
        siteUrl.isAcceptableOrUnknown(data['site_url']!, _siteUrlMeta),
      );
    } else if (isInserting) {
      context.missing(_siteUrlMeta);
    }
    if (data.containsKey('url')) {
      context.handle(
        _urlMeta,
        url.isAcceptableOrUnknown(data['url']!, _urlMeta),
      );
    } else if (isInserting) {
      context.missing(_urlMeta);
    }
    if (data.containsKey('title')) {
      context.handle(
        _titleMeta,
        title.isAcceptableOrUnknown(data['title']!, _titleMeta),
      );
    } else if (isInserting) {
      context.missing(_titleMeta);
    }
    if (data.containsKey('date')) {
      context.handle(
        _dateMeta,
        date.isAcceptableOrUnknown(data['date']!, _dateMeta),
      );
    } else if (isInserting) {
      context.missing(_dateMeta);
    }
    if (data.containsKey('found_at')) {
      context.handle(
        _foundAtMeta,
        foundAt.isAcceptableOrUnknown(data['found_at']!, _foundAtMeta),
      );
    }
    if (data.containsKey('read_at')) {
      context.handle(
        _readAtMeta,
        readAt.isAcceptableOrUnknown(data['read_at']!, _readAtMeta),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {siteUrl, url};
  @override
  FeedEntry map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return FeedEntry(
      siteUrl: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}site_url'],
      )!,
      url: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}url'],
      )!,
      title: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}title'],
      )!,
      date: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}date'],
      )!,
      foundAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}found_at'],
      )!,
      readAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}read_at'],
      ),
    );
  }

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

class FeedEntry extends DataClass implements Insertable<FeedEntry> {
  final String siteUrl;
  final String url;
  final String title;
  final DateTime date;
  final DateTime foundAt;
  final DateTime? readAt;
  const FeedEntry({
    required this.siteUrl,
    required this.url,
    required this.title,
    required this.date,
    required this.foundAt,
    this.readAt,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['site_url'] = Variable<String>(siteUrl);
    map['url'] = Variable<String>(url);
    map['title'] = Variable<String>(title);
    map['date'] = Variable<DateTime>(date);
    map['found_at'] = Variable<DateTime>(foundAt);
    if (!nullToAbsent || readAt != null) {
      map['read_at'] = Variable<DateTime>(readAt);
    }
    return map;
  }

  FeedEntriesCompanion toCompanion(bool nullToAbsent) {
    return FeedEntriesCompanion(
      siteUrl: Value(siteUrl),
      url: Value(url),
      title: Value(title),
      date: Value(date),
      foundAt: Value(foundAt),
      readAt: readAt == null && nullToAbsent
          ? const Value.absent()
          : Value(readAt),
    );
  }

  factory FeedEntry.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return FeedEntry(
      siteUrl: serializer.fromJson<String>(json['siteUrl']),
      url: serializer.fromJson<String>(json['url']),
      title: serializer.fromJson<String>(json['title']),
      date: serializer.fromJson<DateTime>(json['date']),
      foundAt: serializer.fromJson<DateTime>(json['foundAt']),
      readAt: serializer.fromJson<DateTime?>(json['readAt']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'siteUrl': serializer.toJson<String>(siteUrl),
      'url': serializer.toJson<String>(url),
      'title': serializer.toJson<String>(title),
      'date': serializer.toJson<DateTime>(date),
      'foundAt': serializer.toJson<DateTime>(foundAt),
      'readAt': serializer.toJson<DateTime?>(readAt),
    };
  }

  FeedEntry copyWith({
    String? siteUrl,
    String? url,
    String? title,
    DateTime? date,
    DateTime? foundAt,
    Value<DateTime?> readAt = const Value.absent(),
  }) => FeedEntry(
    siteUrl: siteUrl ?? this.siteUrl,
    url: url ?? this.url,
    title: title ?? this.title,
    date: date ?? this.date,
    foundAt: foundAt ?? this.foundAt,
    readAt: readAt.present ? readAt.value : this.readAt,
  );
  FeedEntry copyWithCompanion(FeedEntriesCompanion data) {
    return FeedEntry(
      siteUrl: data.siteUrl.present ? data.siteUrl.value : this.siteUrl,
      url: data.url.present ? data.url.value : this.url,
      title: data.title.present ? data.title.value : this.title,
      date: data.date.present ? data.date.value : this.date,
      foundAt: data.foundAt.present ? data.foundAt.value : this.foundAt,
      readAt: data.readAt.present ? data.readAt.value : this.readAt,
    );
  }

  @override
  String toString() {
    return (StringBuffer('FeedEntry(')
          ..write('siteUrl: $siteUrl, ')
          ..write('url: $url, ')
          ..write('title: $title, ')
          ..write('date: $date, ')
          ..write('foundAt: $foundAt, ')
          ..write('readAt: $readAt')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(siteUrl, url, title, date, foundAt, readAt);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is FeedEntry &&
          other.siteUrl == this.siteUrl &&
          other.url == this.url &&
          other.title == this.title &&
          other.date == this.date &&
          other.foundAt == this.foundAt &&
          other.readAt == this.readAt);
}

class FeedEntriesCompanion extends UpdateCompanion<FeedEntry> {
  final Value<String> siteUrl;
  final Value<String> url;
  final Value<String> title;
  final Value<DateTime> date;
  final Value<DateTime> foundAt;
  final Value<DateTime?> readAt;
  final Value<int> rowid;
  const FeedEntriesCompanion({
    this.siteUrl = const Value.absent(),
    this.url = const Value.absent(),
    this.title = const Value.absent(),
    this.date = const Value.absent(),
    this.foundAt = const Value.absent(),
    this.readAt = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  FeedEntriesCompanion.insert({
    required String siteUrl,
    required String url,
    required String title,
    required DateTime date,
    this.foundAt = const Value.absent(),
    this.readAt = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : siteUrl = Value(siteUrl),
       url = Value(url),
       title = Value(title),
       date = Value(date);
  static Insertable<FeedEntry> custom({
    Expression<String>? siteUrl,
    Expression<String>? url,
    Expression<String>? title,
    Expression<DateTime>? date,
    Expression<DateTime>? foundAt,
    Expression<DateTime>? readAt,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (siteUrl != null) 'site_url': siteUrl,
      if (url != null) 'url': url,
      if (title != null) 'title': title,
      if (date != null) 'date': date,
      if (foundAt != null) 'found_at': foundAt,
      if (readAt != null) 'read_at': readAt,
      if (rowid != null) 'rowid': rowid,
    });
  }

  FeedEntriesCompanion copyWith({
    Value<String>? siteUrl,
    Value<String>? url,
    Value<String>? title,
    Value<DateTime>? date,
    Value<DateTime>? foundAt,
    Value<DateTime?>? readAt,
    Value<int>? rowid,
  }) {
    return FeedEntriesCompanion(
      siteUrl: siteUrl ?? this.siteUrl,
      url: url ?? this.url,
      title: title ?? this.title,
      date: date ?? this.date,
      foundAt: foundAt ?? this.foundAt,
      readAt: readAt ?? this.readAt,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (siteUrl.present) {
      map['site_url'] = Variable<String>(siteUrl.value);
    }
    if (url.present) {
      map['url'] = Variable<String>(url.value);
    }
    if (title.present) {
      map['title'] = Variable<String>(title.value);
    }
    if (date.present) {
      map['date'] = Variable<DateTime>(date.value);
    }
    if (foundAt.present) {
      map['found_at'] = Variable<DateTime>(foundAt.value);
    }
    if (readAt.present) {
      map['read_at'] = Variable<DateTime>(readAt.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('FeedEntriesCompanion(')
          ..write('siteUrl: $siteUrl, ')
          ..write('url: $url, ')
          ..write('title: $title, ')
          ..write('date: $date, ')
          ..write('foundAt: $foundAt, ')
          ..write('readAt: $readAt, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $ItemTagsTable extends ItemTags with TableInfo<$ItemTagsTable, ItemTag> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $ItemTagsTable(this.attachedDatabase, [this._alias]);
  @override
  late final GeneratedColumnWithTypeConverter<TagKind, String> kind =
      GeneratedColumn<String>(
        'kind',
        aliasedName,
        false,
        type: DriftSqlType.string,
        requiredDuringInsert: true,
      ).withConverter<TagKind>($ItemTagsTable.$converterkind);
  static const VerificationMeta _urlMeta = const VerificationMeta('url');
  @override
  late final GeneratedColumn<String> url = GeneratedColumn<String>(
    'url',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _tagMeta = const VerificationMeta('tag');
  @override
  late final GeneratedColumn<String> tag = GeneratedColumn<String>(
    'tag',
    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: false,
    defaultValue: currentDateAndTime,
  );
  @override
  List<GeneratedColumn> get $columns => [kind, url, tag, createdAt];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'item_tags';
  @override
  VerificationContext validateIntegrity(
    Insertable<ItemTag> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('url')) {
      context.handle(
        _urlMeta,
        url.isAcceptableOrUnknown(data['url']!, _urlMeta),
      );
    } else if (isInserting) {
      context.missing(_urlMeta);
    }
    if (data.containsKey('tag')) {
      context.handle(
        _tagMeta,
        tag.isAcceptableOrUnknown(data['tag']!, _tagMeta),
      );
    } else if (isInserting) {
      context.missing(_tagMeta);
    }
    if (data.containsKey('created_at')) {
      context.handle(
        _createdAtMeta,
        createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {kind, url, tag};
  @override
  ItemTag map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return ItemTag(
      kind: $ItemTagsTable.$converterkind.fromSql(
        attachedDatabase.typeMapping.read(
          DriftSqlType.string,
          data['${effectivePrefix}kind'],
        )!,
      ),
      url: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}url'],
      )!,
      tag: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}tag'],
      )!,
      createdAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}created_at'],
      )!,
    );
  }

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

  static JsonTypeConverter2<TagKind, String, String> $converterkind =
      const EnumNameConverter<TagKind>(TagKind.values);
}

class ItemTag extends DataClass implements Insertable<ItemTag> {
  final TagKind kind;
  final String url;
  final String tag;
  final DateTime createdAt;
  const ItemTag({
    required this.kind,
    required this.url,
    required this.tag,
    required this.createdAt,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    {
      map['kind'] = Variable<String>($ItemTagsTable.$converterkind.toSql(kind));
    }
    map['url'] = Variable<String>(url);
    map['tag'] = Variable<String>(tag);
    map['created_at'] = Variable<DateTime>(createdAt);
    return map;
  }

  ItemTagsCompanion toCompanion(bool nullToAbsent) {
    return ItemTagsCompanion(
      kind: Value(kind),
      url: Value(url),
      tag: Value(tag),
      createdAt: Value(createdAt),
    );
  }

  factory ItemTag.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return ItemTag(
      kind: $ItemTagsTable.$converterkind.fromJson(
        serializer.fromJson<String>(json['kind']),
      ),
      url: serializer.fromJson<String>(json['url']),
      tag: serializer.fromJson<String>(json['tag']),
      createdAt: serializer.fromJson<DateTime>(json['createdAt']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'kind': serializer.toJson<String>(
        $ItemTagsTable.$converterkind.toJson(kind),
      ),
      'url': serializer.toJson<String>(url),
      'tag': serializer.toJson<String>(tag),
      'createdAt': serializer.toJson<DateTime>(createdAt),
    };
  }

  ItemTag copyWith({
    TagKind? kind,
    String? url,
    String? tag,
    DateTime? createdAt,
  }) => ItemTag(
    kind: kind ?? this.kind,
    url: url ?? this.url,
    tag: tag ?? this.tag,
    createdAt: createdAt ?? this.createdAt,
  );
  ItemTag copyWithCompanion(ItemTagsCompanion data) {
    return ItemTag(
      kind: data.kind.present ? data.kind.value : this.kind,
      url: data.url.present ? data.url.value : this.url,
      tag: data.tag.present ? data.tag.value : this.tag,
      createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
    );
  }

  @override
  String toString() {
    return (StringBuffer('ItemTag(')
          ..write('kind: $kind, ')
          ..write('url: $url, ')
          ..write('tag: $tag, ')
          ..write('createdAt: $createdAt')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(kind, url, tag, createdAt);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is ItemTag &&
          other.kind == this.kind &&
          other.url == this.url &&
          other.tag == this.tag &&
          other.createdAt == this.createdAt);
}

class ItemTagsCompanion extends UpdateCompanion<ItemTag> {
  final Value<TagKind> kind;
  final Value<String> url;
  final Value<String> tag;
  final Value<DateTime> createdAt;
  final Value<int> rowid;
  const ItemTagsCompanion({
    this.kind = const Value.absent(),
    this.url = const Value.absent(),
    this.tag = const Value.absent(),
    this.createdAt = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  ItemTagsCompanion.insert({
    required TagKind kind,
    required String url,
    required String tag,
    this.createdAt = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : kind = Value(kind),
       url = Value(url),
       tag = Value(tag);
  static Insertable<ItemTag> custom({
    Expression<String>? kind,
    Expression<String>? url,
    Expression<String>? tag,
    Expression<DateTime>? createdAt,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (kind != null) 'kind': kind,
      if (url != null) 'url': url,
      if (tag != null) 'tag': tag,
      if (createdAt != null) 'created_at': createdAt,
      if (rowid != null) 'rowid': rowid,
    });
  }

  ItemTagsCompanion copyWith({
    Value<TagKind>? kind,
    Value<String>? url,
    Value<String>? tag,
    Value<DateTime>? createdAt,
    Value<int>? rowid,
  }) {
    return ItemTagsCompanion(
      kind: kind ?? this.kind,
      url: url ?? this.url,
      tag: tag ?? this.tag,
      createdAt: createdAt ?? this.createdAt,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (kind.present) {
      map['kind'] = Variable<String>(
        $ItemTagsTable.$converterkind.toSql(kind.value),
      );
    }
    if (url.present) {
      map['url'] = Variable<String>(url.value);
    }
    if (tag.present) {
      map['tag'] = Variable<String>(tag.value);
    }
    if (createdAt.present) {
      map['created_at'] = Variable<DateTime>(createdAt.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('ItemTagsCompanion(')
          ..write('kind: $kind, ')
          ..write('url: $url, ')
          ..write('tag: $tag, ')
          ..write('createdAt: $createdAt, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $ReaderSettingsTable extends ReaderSettings
    with TableInfo<$ReaderSettingsTable, ReaderSetting> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $ReaderSettingsTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<int> id = GeneratedColumn<int>(
    'id',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultValue: const Constant(0),
  );
  static const VerificationMeta _fontMeta = const VerificationMeta('font');
  @override
  late final GeneratedColumn<String> font = GeneratedColumn<String>(
    'font',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    defaultValue: const Constant('Atkinson Hyperlegible'),
  );
  static const VerificationMeta _fontScaleMeta = const VerificationMeta(
    'fontScale',
  );
  @override
  late final GeneratedColumn<double> fontScale = GeneratedColumn<double>(
    'font_scale',
    aliasedName,
    false,
    type: DriftSqlType.double,
    requiredDuringInsert: false,
    defaultValue: const Constant(1.0),
  );
  static const VerificationMeta _themeModeMeta = const VerificationMeta(
    'themeMode',
  );
  @override
  late final GeneratedColumn<String> themeMode = GeneratedColumn<String>(
    'theme_mode',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    defaultValue: const Constant('system'),
  );
  static const VerificationMeta _variantMeta = const VerificationMeta(
    'variant',
  );
  @override
  late final GeneratedColumn<String> variant = GeneratedColumn<String>(
    'variant',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    defaultValue: const Constant('site'),
  );
  static const VerificationMeta _languageMeta = const VerificationMeta(
    'language',
  );
  @override
  late final GeneratedColumn<String> language = GeneratedColumn<String>(
    'language',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    defaultValue: const Constant('system'),
  );
  @override
  List<GeneratedColumn> get $columns => [
    id,
    font,
    fontScale,
    themeMode,
    variant,
    language,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'reader_settings';
  @override
  VerificationContext validateIntegrity(
    Insertable<ReaderSetting> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    }
    if (data.containsKey('font')) {
      context.handle(
        _fontMeta,
        font.isAcceptableOrUnknown(data['font']!, _fontMeta),
      );
    }
    if (data.containsKey('font_scale')) {
      context.handle(
        _fontScaleMeta,
        fontScale.isAcceptableOrUnknown(data['font_scale']!, _fontScaleMeta),
      );
    }
    if (data.containsKey('theme_mode')) {
      context.handle(
        _themeModeMeta,
        themeMode.isAcceptableOrUnknown(data['theme_mode']!, _themeModeMeta),
      );
    }
    if (data.containsKey('variant')) {
      context.handle(
        _variantMeta,
        variant.isAcceptableOrUnknown(data['variant']!, _variantMeta),
      );
    }
    if (data.containsKey('language')) {
      context.handle(
        _languageMeta,
        language.isAcceptableOrUnknown(data['language']!, _languageMeta),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  ReaderSetting map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return ReaderSetting(
      id: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}id'],
      )!,
      font: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}font'],
      )!,
      fontScale: attachedDatabase.typeMapping.read(
        DriftSqlType.double,
        data['${effectivePrefix}font_scale'],
      )!,
      themeMode: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}theme_mode'],
      )!,
      variant: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}variant'],
      )!,
      language: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}language'],
      )!,
    );
  }

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

class ReaderSetting extends DataClass implements Insertable<ReaderSetting> {
  final int id;
  final String font;
  final double fontScale;
  final String themeMode;
  final String variant;
  final String language;
  const ReaderSetting({
    required this.id,
    required this.font,
    required this.fontScale,
    required this.themeMode,
    required this.variant,
    required this.language,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<int>(id);
    map['font'] = Variable<String>(font);
    map['font_scale'] = Variable<double>(fontScale);
    map['theme_mode'] = Variable<String>(themeMode);
    map['variant'] = Variable<String>(variant);
    map['language'] = Variable<String>(language);
    return map;
  }

  ReaderSettingsCompanion toCompanion(bool nullToAbsent) {
    return ReaderSettingsCompanion(
      id: Value(id),
      font: Value(font),
      fontScale: Value(fontScale),
      themeMode: Value(themeMode),
      variant: Value(variant),
      language: Value(language),
    );
  }

  factory ReaderSetting.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return ReaderSetting(
      id: serializer.fromJson<int>(json['id']),
      font: serializer.fromJson<String>(json['font']),
      fontScale: serializer.fromJson<double>(json['fontScale']),
      themeMode: serializer.fromJson<String>(json['themeMode']),
      variant: serializer.fromJson<String>(json['variant']),
      language: serializer.fromJson<String>(json['language']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'id': serializer.toJson<int>(id),
      'font': serializer.toJson<String>(font),
      'fontScale': serializer.toJson<double>(fontScale),
      'themeMode': serializer.toJson<String>(themeMode),
      'variant': serializer.toJson<String>(variant),
      'language': serializer.toJson<String>(language),
    };
  }

  ReaderSetting copyWith({
    int? id,
    String? font,
    double? fontScale,
    String? themeMode,
    String? variant,
    String? language,
  }) => ReaderSetting(
    id: id ?? this.id,
    font: font ?? this.font,
    fontScale: fontScale ?? this.fontScale,
    themeMode: themeMode ?? this.themeMode,
    variant: variant ?? this.variant,
    language: language ?? this.language,
  );
  ReaderSetting copyWithCompanion(ReaderSettingsCompanion data) {
    return ReaderSetting(
      id: data.id.present ? data.id.value : this.id,
      font: data.font.present ? data.font.value : this.font,
      fontScale: data.fontScale.present ? data.fontScale.value : this.fontScale,
      themeMode: data.themeMode.present ? data.themeMode.value : this.themeMode,
      variant: data.variant.present ? data.variant.value : this.variant,
      language: data.language.present ? data.language.value : this.language,
    );
  }

  @override
  String toString() {
    return (StringBuffer('ReaderSetting(')
          ..write('id: $id, ')
          ..write('font: $font, ')
          ..write('fontScale: $fontScale, ')
          ..write('themeMode: $themeMode, ')
          ..write('variant: $variant, ')
          ..write('language: $language')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode =>
      Object.hash(id, font, fontScale, themeMode, variant, language);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is ReaderSetting &&
          other.id == this.id &&
          other.font == this.font &&
          other.fontScale == this.fontScale &&
          other.themeMode == this.themeMode &&
          other.variant == this.variant &&
          other.language == this.language);
}

class ReaderSettingsCompanion extends UpdateCompanion<ReaderSetting> {
  final Value<int> id;
  final Value<String> font;
  final Value<double> fontScale;
  final Value<String> themeMode;
  final Value<String> variant;
  final Value<String> language;
  const ReaderSettingsCompanion({
    this.id = const Value.absent(),
    this.font = const Value.absent(),
    this.fontScale = const Value.absent(),
    this.themeMode = const Value.absent(),
    this.variant = const Value.absent(),
    this.language = const Value.absent(),
  });
  ReaderSettingsCompanion.insert({
    this.id = const Value.absent(),
    this.font = const Value.absent(),
    this.fontScale = const Value.absent(),
    this.themeMode = const Value.absent(),
    this.variant = const Value.absent(),
    this.language = const Value.absent(),
  });
  static Insertable<ReaderSetting> custom({
    Expression<int>? id,
    Expression<String>? font,
    Expression<double>? fontScale,
    Expression<String>? themeMode,
    Expression<String>? variant,
    Expression<String>? language,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (font != null) 'font': font,
      if (fontScale != null) 'font_scale': fontScale,
      if (themeMode != null) 'theme_mode': themeMode,
      if (variant != null) 'variant': variant,
      if (language != null) 'language': language,
    });
  }

  ReaderSettingsCompanion copyWith({
    Value<int>? id,
    Value<String>? font,
    Value<double>? fontScale,
    Value<String>? themeMode,
    Value<String>? variant,
    Value<String>? language,
  }) {
    return ReaderSettingsCompanion(
      id: id ?? this.id,
      font: font ?? this.font,
      fontScale: fontScale ?? this.fontScale,
      themeMode: themeMode ?? this.themeMode,
      variant: variant ?? this.variant,
      language: language ?? this.language,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<int>(id.value);
    }
    if (font.present) {
      map['font'] = Variable<String>(font.value);
    }
    if (fontScale.present) {
      map['font_scale'] = Variable<double>(fontScale.value);
    }
    if (themeMode.present) {
      map['theme_mode'] = Variable<String>(themeMode.value);
    }
    if (variant.present) {
      map['variant'] = Variable<String>(variant.value);
    }
    if (language.present) {
      map['language'] = Variable<String>(language.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('ReaderSettingsCompanion(')
          ..write('id: $id, ')
          ..write('font: $font, ')
          ..write('fontScale: $fontScale, ')
          ..write('themeMode: $themeMode, ')
          ..write('variant: $variant, ')
          ..write('language: $language')
          ..write(')'))
        .toString();
  }
}

class $CachedPagesTable extends CachedPages
    with TableInfo<$CachedPagesTable, CachedPage> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $CachedPagesTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _urlMeta = const VerificationMeta('url');
  @override
  late final GeneratedColumn<String> url = GeneratedColumn<String>(
    'url',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _titleMeta = const VerificationMeta('title');
  @override
  late final GeneratedColumn<String> title = GeneratedColumn<String>(
    'title',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
  );
  static const VerificationMeta _sourceMeta = const VerificationMeta('source');
  @override
  late final GeneratedColumn<String> source = GeneratedColumn<String>(
    'source',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _etagMeta = const VerificationMeta('etag');
  @override
  late final GeneratedColumn<String> etag = GeneratedColumn<String>(
    'etag',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
  );
  static const VerificationMeta _lastModifiedMeta = const VerificationMeta(
    'lastModified',
  );
  @override
  late final GeneratedColumn<String> lastModified = GeneratedColumn<String>(
    'last_modified',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
  );
  static const VerificationMeta _cachedAtMeta = const VerificationMeta(
    'cachedAt',
  );
  @override
  late final GeneratedColumn<DateTime> cachedAt = GeneratedColumn<DateTime>(
    'cached_at',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: false,
    defaultValue: currentDateAndTime,
  );
  @override
  List<GeneratedColumn> get $columns => [
    url,
    title,
    source,
    etag,
    lastModified,
    cachedAt,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'cached_pages';
  @override
  VerificationContext validateIntegrity(
    Insertable<CachedPage> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('url')) {
      context.handle(
        _urlMeta,
        url.isAcceptableOrUnknown(data['url']!, _urlMeta),
      );
    } else if (isInserting) {
      context.missing(_urlMeta);
    }
    if (data.containsKey('title')) {
      context.handle(
        _titleMeta,
        title.isAcceptableOrUnknown(data['title']!, _titleMeta),
      );
    }
    if (data.containsKey('source')) {
      context.handle(
        _sourceMeta,
        source.isAcceptableOrUnknown(data['source']!, _sourceMeta),
      );
    } else if (isInserting) {
      context.missing(_sourceMeta);
    }
    if (data.containsKey('etag')) {
      context.handle(
        _etagMeta,
        etag.isAcceptableOrUnknown(data['etag']!, _etagMeta),
      );
    }
    if (data.containsKey('last_modified')) {
      context.handle(
        _lastModifiedMeta,
        lastModified.isAcceptableOrUnknown(
          data['last_modified']!,
          _lastModifiedMeta,
        ),
      );
    }
    if (data.containsKey('cached_at')) {
      context.handle(
        _cachedAtMeta,
        cachedAt.isAcceptableOrUnknown(data['cached_at']!, _cachedAtMeta),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {url};
  @override
  CachedPage map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return CachedPage(
      url: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}url'],
      )!,
      title: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}title'],
      ),
      source: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}source'],
      )!,
      etag: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}etag'],
      ),
      lastModified: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}last_modified'],
      ),
      cachedAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}cached_at'],
      )!,
    );
  }

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

class CachedPage extends DataClass implements Insertable<CachedPage> {
  final String url;
  final String? title;
  final String source;
  final String? etag;
  final String? lastModified;
  final DateTime cachedAt;
  const CachedPage({
    required this.url,
    this.title,
    required this.source,
    this.etag,
    this.lastModified,
    required this.cachedAt,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['url'] = Variable<String>(url);
    if (!nullToAbsent || title != null) {
      map['title'] = Variable<String>(title);
    }
    map['source'] = Variable<String>(source);
    if (!nullToAbsent || etag != null) {
      map['etag'] = Variable<String>(etag);
    }
    if (!nullToAbsent || lastModified != null) {
      map['last_modified'] = Variable<String>(lastModified);
    }
    map['cached_at'] = Variable<DateTime>(cachedAt);
    return map;
  }

  CachedPagesCompanion toCompanion(bool nullToAbsent) {
    return CachedPagesCompanion(
      url: Value(url),
      title: title == null && nullToAbsent
          ? const Value.absent()
          : Value(title),
      source: Value(source),
      etag: etag == null && nullToAbsent ? const Value.absent() : Value(etag),
      lastModified: lastModified == null && nullToAbsent
          ? const Value.absent()
          : Value(lastModified),
      cachedAt: Value(cachedAt),
    );
  }

  factory CachedPage.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return CachedPage(
      url: serializer.fromJson<String>(json['url']),
      title: serializer.fromJson<String?>(json['title']),
      source: serializer.fromJson<String>(json['source']),
      etag: serializer.fromJson<String?>(json['etag']),
      lastModified: serializer.fromJson<String?>(json['lastModified']),
      cachedAt: serializer.fromJson<DateTime>(json['cachedAt']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'url': serializer.toJson<String>(url),
      'title': serializer.toJson<String?>(title),
      'source': serializer.toJson<String>(source),
      'etag': serializer.toJson<String?>(etag),
      'lastModified': serializer.toJson<String?>(lastModified),
      'cachedAt': serializer.toJson<DateTime>(cachedAt),
    };
  }

  CachedPage copyWith({
    String? url,
    Value<String?> title = const Value.absent(),
    String? source,
    Value<String?> etag = const Value.absent(),
    Value<String?> lastModified = const Value.absent(),
    DateTime? cachedAt,
  }) => CachedPage(
    url: url ?? this.url,
    title: title.present ? title.value : this.title,
    source: source ?? this.source,
    etag: etag.present ? etag.value : this.etag,
    lastModified: lastModified.present ? lastModified.value : this.lastModified,
    cachedAt: cachedAt ?? this.cachedAt,
  );
  CachedPage copyWithCompanion(CachedPagesCompanion data) {
    return CachedPage(
      url: data.url.present ? data.url.value : this.url,
      title: data.title.present ? data.title.value : this.title,
      source: data.source.present ? data.source.value : this.source,
      etag: data.etag.present ? data.etag.value : this.etag,
      lastModified: data.lastModified.present
          ? data.lastModified.value
          : this.lastModified,
      cachedAt: data.cachedAt.present ? data.cachedAt.value : this.cachedAt,
    );
  }

  @override
  String toString() {
    return (StringBuffer('CachedPage(')
          ..write('url: $url, ')
          ..write('title: $title, ')
          ..write('source: $source, ')
          ..write('etag: $etag, ')
          ..write('lastModified: $lastModified, ')
          ..write('cachedAt: $cachedAt')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode =>
      Object.hash(url, title, source, etag, lastModified, cachedAt);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is CachedPage &&
          other.url == this.url &&
          other.title == this.title &&
          other.source == this.source &&
          other.etag == this.etag &&
          other.lastModified == this.lastModified &&
          other.cachedAt == this.cachedAt);
}

class CachedPagesCompanion extends UpdateCompanion<CachedPage> {
  final Value<String> url;
  final Value<String?> title;
  final Value<String> source;
  final Value<String?> etag;
  final Value<String?> lastModified;
  final Value<DateTime> cachedAt;
  final Value<int> rowid;
  const CachedPagesCompanion({
    this.url = const Value.absent(),
    this.title = const Value.absent(),
    this.source = const Value.absent(),
    this.etag = const Value.absent(),
    this.lastModified = const Value.absent(),
    this.cachedAt = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  CachedPagesCompanion.insert({
    required String url,
    this.title = const Value.absent(),
    required String source,
    this.etag = const Value.absent(),
    this.lastModified = const Value.absent(),
    this.cachedAt = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : url = Value(url),
       source = Value(source);
  static Insertable<CachedPage> custom({
    Expression<String>? url,
    Expression<String>? title,
    Expression<String>? source,
    Expression<String>? etag,
    Expression<String>? lastModified,
    Expression<DateTime>? cachedAt,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (url != null) 'url': url,
      if (title != null) 'title': title,
      if (source != null) 'source': source,
      if (etag != null) 'etag': etag,
      if (lastModified != null) 'last_modified': lastModified,
      if (cachedAt != null) 'cached_at': cachedAt,
      if (rowid != null) 'rowid': rowid,
    });
  }

  CachedPagesCompanion copyWith({
    Value<String>? url,
    Value<String?>? title,
    Value<String>? source,
    Value<String?>? etag,
    Value<String?>? lastModified,
    Value<DateTime>? cachedAt,
    Value<int>? rowid,
  }) {
    return CachedPagesCompanion(
      url: url ?? this.url,
      title: title ?? this.title,
      source: source ?? this.source,
      etag: etag ?? this.etag,
      lastModified: lastModified ?? this.lastModified,
      cachedAt: cachedAt ?? this.cachedAt,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (url.present) {
      map['url'] = Variable<String>(url.value);
    }
    if (title.present) {
      map['title'] = Variable<String>(title.value);
    }
    if (source.present) {
      map['source'] = Variable<String>(source.value);
    }
    if (etag.present) {
      map['etag'] = Variable<String>(etag.value);
    }
    if (lastModified.present) {
      map['last_modified'] = Variable<String>(lastModified.value);
    }
    if (cachedAt.present) {
      map['cached_at'] = Variable<DateTime>(cachedAt.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('CachedPagesCompanion(')
          ..write('url: $url, ')
          ..write('title: $title, ')
          ..write('source: $source, ')
          ..write('etag: $etag, ')
          ..write('lastModified: $lastModified, ')
          ..write('cachedAt: $cachedAt, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $KnownHostsTable extends KnownHosts
    with TableInfo<$KnownHostsTable, KnownHost> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $KnownHostsTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _hostMeta = const VerificationMeta('host');
  @override
  late final GeneratedColumn<String> host = GeneratedColumn<String>(
    'host',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _portMeta = const VerificationMeta('port');
  @override
  late final GeneratedColumn<int> port = GeneratedColumn<int>(
    'port',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _fingerprintMeta = const VerificationMeta(
    'fingerprint',
  );
  @override
  late final GeneratedColumn<String> fingerprint = GeneratedColumn<String>(
    'fingerprint',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _expiresMeta = const VerificationMeta(
    'expires',
  );
  @override
  late final GeneratedColumn<DateTime> expires = GeneratedColumn<DateTime>(
    'expires',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _pinnedAtMeta = const VerificationMeta(
    'pinnedAt',
  );
  @override
  late final GeneratedColumn<DateTime> pinnedAt = GeneratedColumn<DateTime>(
    'pinned_at',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: false,
    defaultValue: currentDateAndTime,
  );
  @override
  List<GeneratedColumn> get $columns => [
    host,
    port,
    fingerprint,
    expires,
    pinnedAt,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'known_hosts';
  @override
  VerificationContext validateIntegrity(
    Insertable<KnownHost> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('host')) {
      context.handle(
        _hostMeta,
        host.isAcceptableOrUnknown(data['host']!, _hostMeta),
      );
    } else if (isInserting) {
      context.missing(_hostMeta);
    }
    if (data.containsKey('port')) {
      context.handle(
        _portMeta,
        port.isAcceptableOrUnknown(data['port']!, _portMeta),
      );
    } else if (isInserting) {
      context.missing(_portMeta);
    }
    if (data.containsKey('fingerprint')) {
      context.handle(
        _fingerprintMeta,
        fingerprint.isAcceptableOrUnknown(
          data['fingerprint']!,
          _fingerprintMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_fingerprintMeta);
    }
    if (data.containsKey('expires')) {
      context.handle(
        _expiresMeta,
        expires.isAcceptableOrUnknown(data['expires']!, _expiresMeta),
      );
    } else if (isInserting) {
      context.missing(_expiresMeta);
    }
    if (data.containsKey('pinned_at')) {
      context.handle(
        _pinnedAtMeta,
        pinnedAt.isAcceptableOrUnknown(data['pinned_at']!, _pinnedAtMeta),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {host, port};
  @override
  KnownHost map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return KnownHost(
      host: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}host'],
      )!,
      port: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}port'],
      )!,
      fingerprint: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}fingerprint'],
      )!,
      expires: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}expires'],
      )!,
      pinnedAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}pinned_at'],
      )!,
    );
  }

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

class KnownHost extends DataClass implements Insertable<KnownHost> {
  final String host;
  final int port;
  final String fingerprint;
  final DateTime expires;
  final DateTime pinnedAt;
  const KnownHost({
    required this.host,
    required this.port,
    required this.fingerprint,
    required this.expires,
    required this.pinnedAt,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['host'] = Variable<String>(host);
    map['port'] = Variable<int>(port);
    map['fingerprint'] = Variable<String>(fingerprint);
    map['expires'] = Variable<DateTime>(expires);
    map['pinned_at'] = Variable<DateTime>(pinnedAt);
    return map;
  }

  KnownHostsCompanion toCompanion(bool nullToAbsent) {
    return KnownHostsCompanion(
      host: Value(host),
      port: Value(port),
      fingerprint: Value(fingerprint),
      expires: Value(expires),
      pinnedAt: Value(pinnedAt),
    );
  }

  factory KnownHost.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return KnownHost(
      host: serializer.fromJson<String>(json['host']),
      port: serializer.fromJson<int>(json['port']),
      fingerprint: serializer.fromJson<String>(json['fingerprint']),
      expires: serializer.fromJson<DateTime>(json['expires']),
      pinnedAt: serializer.fromJson<DateTime>(json['pinnedAt']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'host': serializer.toJson<String>(host),
      'port': serializer.toJson<int>(port),
      'fingerprint': serializer.toJson<String>(fingerprint),
      'expires': serializer.toJson<DateTime>(expires),
      'pinnedAt': serializer.toJson<DateTime>(pinnedAt),
    };
  }

  KnownHost copyWith({
    String? host,
    int? port,
    String? fingerprint,
    DateTime? expires,
    DateTime? pinnedAt,
  }) => KnownHost(
    host: host ?? this.host,
    port: port ?? this.port,
    fingerprint: fingerprint ?? this.fingerprint,
    expires: expires ?? this.expires,
    pinnedAt: pinnedAt ?? this.pinnedAt,
  );
  KnownHost copyWithCompanion(KnownHostsCompanion data) {
    return KnownHost(
      host: data.host.present ? data.host.value : this.host,
      port: data.port.present ? data.port.value : this.port,
      fingerprint: data.fingerprint.present
          ? data.fingerprint.value
          : this.fingerprint,
      expires: data.expires.present ? data.expires.value : this.expires,
      pinnedAt: data.pinnedAt.present ? data.pinnedAt.value : this.pinnedAt,
    );
  }

  @override
  String toString() {
    return (StringBuffer('KnownHost(')
          ..write('host: $host, ')
          ..write('port: $port, ')
          ..write('fingerprint: $fingerprint, ')
          ..write('expires: $expires, ')
          ..write('pinnedAt: $pinnedAt')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(host, port, fingerprint, expires, pinnedAt);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is KnownHost &&
          other.host == this.host &&
          other.port == this.port &&
          other.fingerprint == this.fingerprint &&
          other.expires == this.expires &&
          other.pinnedAt == this.pinnedAt);
}

class KnownHostsCompanion extends UpdateCompanion<KnownHost> {
  final Value<String> host;
  final Value<int> port;
  final Value<String> fingerprint;
  final Value<DateTime> expires;
  final Value<DateTime> pinnedAt;
  final Value<int> rowid;
  const KnownHostsCompanion({
    this.host = const Value.absent(),
    this.port = const Value.absent(),
    this.fingerprint = const Value.absent(),
    this.expires = const Value.absent(),
    this.pinnedAt = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  KnownHostsCompanion.insert({
    required String host,
    required int port,
    required String fingerprint,
    required DateTime expires,
    this.pinnedAt = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : host = Value(host),
       port = Value(port),
       fingerprint = Value(fingerprint),
       expires = Value(expires);
  static Insertable<KnownHost> custom({
    Expression<String>? host,
    Expression<int>? port,
    Expression<String>? fingerprint,
    Expression<DateTime>? expires,
    Expression<DateTime>? pinnedAt,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (host != null) 'host': host,
      if (port != null) 'port': port,
      if (fingerprint != null) 'fingerprint': fingerprint,
      if (expires != null) 'expires': expires,
      if (pinnedAt != null) 'pinned_at': pinnedAt,
      if (rowid != null) 'rowid': rowid,
    });
  }

  KnownHostsCompanion copyWith({
    Value<String>? host,
    Value<int>? port,
    Value<String>? fingerprint,
    Value<DateTime>? expires,
    Value<DateTime>? pinnedAt,
    Value<int>? rowid,
  }) {
    return KnownHostsCompanion(
      host: host ?? this.host,
      port: port ?? this.port,
      fingerprint: fingerprint ?? this.fingerprint,
      expires: expires ?? this.expires,
      pinnedAt: pinnedAt ?? this.pinnedAt,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (host.present) {
      map['host'] = Variable<String>(host.value);
    }
    if (port.present) {
      map['port'] = Variable<int>(port.value);
    }
    if (fingerprint.present) {
      map['fingerprint'] = Variable<String>(fingerprint.value);
    }
    if (expires.present) {
      map['expires'] = Variable<DateTime>(expires.value);
    }
    if (pinnedAt.present) {
      map['pinned_at'] = Variable<DateTime>(pinnedAt.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('KnownHostsCompanion(')
          ..write('host: $host, ')
          ..write('port: $port, ')
          ..write('fingerprint: $fingerprint, ')
          ..write('expires: $expires, ')
          ..write('pinnedAt: $pinnedAt, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $ClientCertificatesTable extends ClientCertificates
    with TableInfo<$ClientCertificatesTable, ClientCertificate> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $ClientCertificatesTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<int> id = GeneratedColumn<int>(
    'id',
    aliasedName,
    false,
    hasAutoIncrement: true,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'PRIMARY KEY AUTOINCREMENT',
    ),
  );
  static const VerificationMeta _nameMeta = const VerificationMeta('name');
  @override
  late final GeneratedColumn<String> name = GeneratedColumn<String>(
    'name',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _certPemMeta = const VerificationMeta(
    'certPem',
  );
  @override
  late final GeneratedColumn<String> certPem = GeneratedColumn<String>(
    'cert_pem',
    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: false,
    defaultValue: currentDateAndTime,
  );
  @override
  List<GeneratedColumn> get $columns => [id, name, certPem, createdAt];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'client_certificates';
  @override
  VerificationContext validateIntegrity(
    Insertable<ClientCertificate> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    }
    if (data.containsKey('name')) {
      context.handle(
        _nameMeta,
        name.isAcceptableOrUnknown(data['name']!, _nameMeta),
      );
    } else if (isInserting) {
      context.missing(_nameMeta);
    }
    if (data.containsKey('cert_pem')) {
      context.handle(
        _certPemMeta,
        certPem.isAcceptableOrUnknown(data['cert_pem']!, _certPemMeta),
      );
    } else if (isInserting) {
      context.missing(_certPemMeta);
    }
    if (data.containsKey('created_at')) {
      context.handle(
        _createdAtMeta,
        createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
      );
    }
    return context;
  }

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

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

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

  ClientCertificatesCompanion toCompanion(bool nullToAbsent) {
    return ClientCertificatesCompanion(
      id: Value(id),
      name: Value(name),
      certPem: Value(certPem),
      createdAt: Value(createdAt),
    );
  }

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

  ClientCertificate copyWith({
    int? id,
    String? name,
    String? certPem,
    DateTime? createdAt,
  }) => ClientCertificate(
    id: id ?? this.id,
    name: name ?? this.name,
    certPem: certPem ?? this.certPem,
    createdAt: createdAt ?? this.createdAt,
  );
  ClientCertificate copyWithCompanion(ClientCertificatesCompanion data) {
    return ClientCertificate(
      id: data.id.present ? data.id.value : this.id,
      name: data.name.present ? data.name.value : this.name,
      certPem: data.certPem.present ? data.certPem.value : this.certPem,
      createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
    );
  }

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

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

class ClientCertificatesCompanion extends UpdateCompanion<ClientCertificate> {
  final Value<int> id;
  final Value<String> name;
  final Value<String> certPem;
  final Value<DateTime> createdAt;
  const ClientCertificatesCompanion({
    this.id = const Value.absent(),
    this.name = const Value.absent(),
    this.certPem = const Value.absent(),
    this.createdAt = const Value.absent(),
  });
  ClientCertificatesCompanion.insert({
    this.id = const Value.absent(),
    required String name,
    required String certPem,
    this.createdAt = const Value.absent(),
  }) : name = Value(name),
       certPem = Value(certPem);
  static Insertable<ClientCertificate> custom({
    Expression<int>? id,
    Expression<String>? name,
    Expression<String>? certPem,
    Expression<DateTime>? createdAt,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (name != null) 'name': name,
      if (certPem != null) 'cert_pem': certPem,
      if (createdAt != null) 'created_at': createdAt,
    });
  }

  ClientCertificatesCompanion copyWith({
    Value<int>? id,
    Value<String>? name,
    Value<String>? certPem,
    Value<DateTime>? createdAt,
  }) {
    return ClientCertificatesCompanion(
      id: id ?? this.id,
      name: name ?? this.name,
      certPem: certPem ?? this.certPem,
      createdAt: createdAt ?? this.createdAt,
    );
  }

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

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

class $SiteCertificatesTable extends SiteCertificates
    with TableInfo<$SiteCertificatesTable, SiteCertificate> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $SiteCertificatesTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _hostMeta = const VerificationMeta('host');
  @override
  late final GeneratedColumn<String> host = GeneratedColumn<String>(
    'host',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _portMeta = const VerificationMeta('port');
  @override
  late final GeneratedColumn<int> port = GeneratedColumn<int>(
    'port',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _certificateIdMeta = const VerificationMeta(
    'certificateId',
  );
  @override
  late final GeneratedColumn<int> certificateId = GeneratedColumn<int>(
    'certificate_id',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
  );
  @override
  List<GeneratedColumn> get $columns => [host, port, certificateId];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'site_certificates';
  @override
  VerificationContext validateIntegrity(
    Insertable<SiteCertificate> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('host')) {
      context.handle(
        _hostMeta,
        host.isAcceptableOrUnknown(data['host']!, _hostMeta),
      );
    } else if (isInserting) {
      context.missing(_hostMeta);
    }
    if (data.containsKey('port')) {
      context.handle(
        _portMeta,
        port.isAcceptableOrUnknown(data['port']!, _portMeta),
      );
    } else if (isInserting) {
      context.missing(_portMeta);
    }
    if (data.containsKey('certificate_id')) {
      context.handle(
        _certificateIdMeta,
        certificateId.isAcceptableOrUnknown(
          data['certificate_id']!,
          _certificateIdMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_certificateIdMeta);
    }
    return context;
  }

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

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

class SiteCertificate extends DataClass implements Insertable<SiteCertificate> {
  final String host;
  final int port;
  final int certificateId;
  const SiteCertificate({
    required this.host,
    required this.port,
    required this.certificateId,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['host'] = Variable<String>(host);
    map['port'] = Variable<int>(port);
    map['certificate_id'] = Variable<int>(certificateId);
    return map;
  }

  SiteCertificatesCompanion toCompanion(bool nullToAbsent) {
    return SiteCertificatesCompanion(
      host: Value(host),
      port: Value(port),
      certificateId: Value(certificateId),
    );
  }

  factory SiteCertificate.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return SiteCertificate(
      host: serializer.fromJson<String>(json['host']),
      port: serializer.fromJson<int>(json['port']),
      certificateId: serializer.fromJson<int>(json['certificateId']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'host': serializer.toJson<String>(host),
      'port': serializer.toJson<int>(port),
      'certificateId': serializer.toJson<int>(certificateId),
    };
  }

  SiteCertificate copyWith({String? host, int? port, int? certificateId}) =>
      SiteCertificate(
        host: host ?? this.host,
        port: port ?? this.port,
        certificateId: certificateId ?? this.certificateId,
      );
  SiteCertificate copyWithCompanion(SiteCertificatesCompanion data) {
    return SiteCertificate(
      host: data.host.present ? data.host.value : this.host,
      port: data.port.present ? data.port.value : this.port,
      certificateId: data.certificateId.present
          ? data.certificateId.value
          : this.certificateId,
    );
  }

  @override
  String toString() {
    return (StringBuffer('SiteCertificate(')
          ..write('host: $host, ')
          ..write('port: $port, ')
          ..write('certificateId: $certificateId')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(host, port, certificateId);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is SiteCertificate &&
          other.host == this.host &&
          other.port == this.port &&
          other.certificateId == this.certificateId);
}

class SiteCertificatesCompanion extends UpdateCompanion<SiteCertificate> {
  final Value<String> host;
  final Value<int> port;
  final Value<int> certificateId;
  final Value<int> rowid;
  const SiteCertificatesCompanion({
    this.host = const Value.absent(),
    this.port = const Value.absent(),
    this.certificateId = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  SiteCertificatesCompanion.insert({
    required String host,
    required int port,
    required int certificateId,
    this.rowid = const Value.absent(),
  }) : host = Value(host),
       port = Value(port),
       certificateId = Value(certificateId);
  static Insertable<SiteCertificate> custom({
    Expression<String>? host,
    Expression<int>? port,
    Expression<int>? certificateId,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (host != null) 'host': host,
      if (port != null) 'port': port,
      if (certificateId != null) 'certificate_id': certificateId,
      if (rowid != null) 'rowid': rowid,
    });
  }

  SiteCertificatesCompanion copyWith({
    Value<String>? host,
    Value<int>? port,
    Value<int>? certificateId,
    Value<int>? rowid,
  }) {
    return SiteCertificatesCompanion(
      host: host ?? this.host,
      port: port ?? this.port,
      certificateId: certificateId ?? this.certificateId,
      rowid: rowid ?? this.rowid,
    );
  }

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

  @override
  String toString() {
    return (StringBuffer('SiteCertificatesCompanion(')
          ..write('host: $host, ')
          ..write('port: $port, ')
          ..write('certificateId: $certificateId, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $FirstStartTable extends FirstStart
    with TableInfo<$FirstStartTable, FirstStartData> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $FirstStartTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<int> id = GeneratedColumn<int>(
    'id',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultValue: const Constant(0),
  );
  static const VerificationMeta _directorySeededMeta = const VerificationMeta(
    'directorySeeded',
  );
  @override
  late final GeneratedColumn<bool> directorySeeded = GeneratedColumn<bool>(
    'directory_seeded',
    aliasedName,
    false,
    type: DriftSqlType.bool,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'CHECK ("directory_seeded" IN (0, 1))',
    ),
    defaultValue: const Constant(false),
  );
  @override
  List<GeneratedColumn> get $columns => [id, directorySeeded];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'first_start';
  @override
  VerificationContext validateIntegrity(
    Insertable<FirstStartData> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    }
    if (data.containsKey('directory_seeded')) {
      context.handle(
        _directorySeededMeta,
        directorySeeded.isAcceptableOrUnknown(
          data['directory_seeded']!,
          _directorySeededMeta,
        ),
      );
    }
    return context;
  }

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

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

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

  FirstStartCompanion toCompanion(bool nullToAbsent) {
    return FirstStartCompanion(
      id: Value(id),
      directorySeeded: Value(directorySeeded),
    );
  }

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

  FirstStartData copyWith({int? id, bool? directorySeeded}) => FirstStartData(
    id: id ?? this.id,
    directorySeeded: directorySeeded ?? this.directorySeeded,
  );
  FirstStartData copyWithCompanion(FirstStartCompanion data) {
    return FirstStartData(
      id: data.id.present ? data.id.value : this.id,
      directorySeeded: data.directorySeeded.present
          ? data.directorySeeded.value
          : this.directorySeeded,
    );
  }

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

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

class FirstStartCompanion extends UpdateCompanion<FirstStartData> {
  final Value<int> id;
  final Value<bool> directorySeeded;
  const FirstStartCompanion({
    this.id = const Value.absent(),
    this.directorySeeded = const Value.absent(),
  });
  FirstStartCompanion.insert({
    this.id = const Value.absent(),
    this.directorySeeded = const Value.absent(),
  });
  static Insertable<FirstStartData> custom({
    Expression<int>? id,
    Expression<bool>? directorySeeded,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (directorySeeded != null) 'directory_seeded': directorySeeded,
    });
  }

  FirstStartCompanion copyWith({Value<int>? id, Value<bool>? directorySeeded}) {
    return FirstStartCompanion(
      id: id ?? this.id,
      directorySeeded: directorySeeded ?? this.directorySeeded,
    );
  }

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

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

abstract class _$MewsDatabase extends GeneratedDatabase {
  _$MewsDatabase(QueryExecutor e) : super(e);
  $MewsDatabaseManager get managers => $MewsDatabaseManager(this);
  late final $HistoryItemsTable historyItems = $HistoryItemsTable(this);
  late final $BookmarksTable bookmarks = $BookmarksTable(this);
  late final $SubscriptionsTable subscriptions = $SubscriptionsTable(this);
  late final $FeedEntriesTable feedEntries = $FeedEntriesTable(this);
  late final $ItemTagsTable itemTags = $ItemTagsTable(this);
  late final $ReaderSettingsTable readerSettings = $ReaderSettingsTable(this);
  late final $CachedPagesTable cachedPages = $CachedPagesTable(this);
  late final $KnownHostsTable knownHosts = $KnownHostsTable(this);
  late final $ClientCertificatesTable clientCertificates =
      $ClientCertificatesTable(this);
  late final $SiteCertificatesTable siteCertificates = $SiteCertificatesTable(
    this,
  );
  late final $FirstStartTable firstStart = $FirstStartTable(this);
  late final Index historyItemsUrl = Index(
    'history_items_url',
    'CREATE INDEX history_items_url ON history_items (url)',
  );
  @override
  Iterable<TableInfo<Table, Object?>> get allTables =>
      allSchemaEntities.whereType<TableInfo<Table, Object?>>();
  @override
  List<DatabaseSchemaEntity> get allSchemaEntities => [
    historyItems,
    bookmarks,
    subscriptions,
    feedEntries,
    itemTags,
    readerSettings,
    cachedPages,
    knownHosts,
    clientCertificates,
    siteCertificates,
    firstStart,
    historyItemsUrl,
  ];
}

typedef $$HistoryItemsTableCreateCompanionBuilder =
    HistoryItemsCompanion Function({
      Value<int> id,
      required String url,
      Value<String?> title,
      Value<DateTime> visitedAt,
    });
typedef $$HistoryItemsTableUpdateCompanionBuilder =
    HistoryItemsCompanion Function({
      Value<int> id,
      Value<String> url,
      Value<String?> title,
      Value<DateTime> visitedAt,
    });

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

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

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

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

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

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

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

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

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

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

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

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

class $$HistoryItemsTableTableManager
    extends
        RootTableManager<
          _$MewsDatabase,
          $HistoryItemsTable,
          HistoryItem,
          $$HistoryItemsTableFilterComposer,
          $$HistoryItemsTableOrderingComposer,
          $$HistoryItemsTableAnnotationComposer,
          $$HistoryItemsTableCreateCompanionBuilder,
          $$HistoryItemsTableUpdateCompanionBuilder,
          (
            HistoryItem,
            BaseReferences<_$MewsDatabase, $HistoryItemsTable, HistoryItem>,
          ),
          HistoryItem,
          PrefetchHooks Function()
        > {
  $$HistoryItemsTableTableManager(_$MewsDatabase db, $HistoryItemsTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$HistoryItemsTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$HistoryItemsTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$HistoryItemsTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                Value<String> url = const Value.absent(),
                Value<String?> title = const Value.absent(),
                Value<DateTime> visitedAt = const Value.absent(),
              }) => HistoryItemsCompanion(
                id: id,
                url: url,
                title: title,
                visitedAt: visitedAt,
              ),
          createCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                required String url,
                Value<String?> title = const Value.absent(),
                Value<DateTime> visitedAt = const Value.absent(),
              }) => HistoryItemsCompanion.insert(
                id: id,
                url: url,
                title: title,
                visitedAt: visitedAt,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$HistoryItemsTableProcessedTableManager =
    ProcessedTableManager<
      _$MewsDatabase,
      $HistoryItemsTable,
      HistoryItem,
      $$HistoryItemsTableFilterComposer,
      $$HistoryItemsTableOrderingComposer,
      $$HistoryItemsTableAnnotationComposer,
      $$HistoryItemsTableCreateCompanionBuilder,
      $$HistoryItemsTableUpdateCompanionBuilder,
      (
        HistoryItem,
        BaseReferences<_$MewsDatabase, $HistoryItemsTable, HistoryItem>,
      ),
      HistoryItem,
      PrefetchHooks Function()
    >;
typedef $$BookmarksTableCreateCompanionBuilder =
    BookmarksCompanion Function({
      required String url,
      Value<String?> title,
      Value<DateTime> createdAt,
      Value<int> rowid,
    });
typedef $$BookmarksTableUpdateCompanionBuilder =
    BookmarksCompanion Function({
      Value<String> url,
      Value<String?> title,
      Value<DateTime> createdAt,
      Value<int> rowid,
    });

class $$BookmarksTableFilterComposer
    extends Composer<_$MewsDatabase, $BookmarksTable> {
  $$BookmarksTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get url => $composableBuilder(
    column: $table.url,
    builder: (column) => ColumnFilters(column),
  );

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

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

class $$BookmarksTableOrderingComposer
    extends Composer<_$MewsDatabase, $BookmarksTable> {
  $$BookmarksTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get url => $composableBuilder(
    column: $table.url,
    builder: (column) => ColumnOrderings(column),
  );

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

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

class $$BookmarksTableAnnotationComposer
    extends Composer<_$MewsDatabase, $BookmarksTable> {
  $$BookmarksTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get url =>
      $composableBuilder(column: $table.url, builder: (column) => column);

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

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

class $$BookmarksTableTableManager
    extends
        RootTableManager<
          _$MewsDatabase,
          $BookmarksTable,
          Bookmark,
          $$BookmarksTableFilterComposer,
          $$BookmarksTableOrderingComposer,
          $$BookmarksTableAnnotationComposer,
          $$BookmarksTableCreateCompanionBuilder,
          $$BookmarksTableUpdateCompanionBuilder,
          (Bookmark, BaseReferences<_$MewsDatabase, $BookmarksTable, Bookmark>),
          Bookmark,
          PrefetchHooks Function()
        > {
  $$BookmarksTableTableManager(_$MewsDatabase db, $BookmarksTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$BookmarksTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$BookmarksTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$BookmarksTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> url = const Value.absent(),
                Value<String?> title = const Value.absent(),
                Value<DateTime> createdAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => BookmarksCompanion(
                url: url,
                title: title,
                createdAt: createdAt,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String url,
                Value<String?> title = const Value.absent(),
                Value<DateTime> createdAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => BookmarksCompanion.insert(
                url: url,
                title: title,
                createdAt: createdAt,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$BookmarksTableProcessedTableManager =
    ProcessedTableManager<
      _$MewsDatabase,
      $BookmarksTable,
      Bookmark,
      $$BookmarksTableFilterComposer,
      $$BookmarksTableOrderingComposer,
      $$BookmarksTableAnnotationComposer,
      $$BookmarksTableCreateCompanionBuilder,
      $$BookmarksTableUpdateCompanionBuilder,
      (Bookmark, BaseReferences<_$MewsDatabase, $BookmarksTable, Bookmark>),
      Bookmark,
      PrefetchHooks Function()
    >;
typedef $$SubscriptionsTableCreateCompanionBuilder =
    SubscriptionsCompanion Function({
      required String url,
      Value<String?> title,
      Value<String?> atomHref,
      Value<DateTime> createdAt,
      Value<DateTime?> lastCheckedAt,
      Value<int> rowid,
    });
typedef $$SubscriptionsTableUpdateCompanionBuilder =
    SubscriptionsCompanion Function({
      Value<String> url,
      Value<String?> title,
      Value<String?> atomHref,
      Value<DateTime> createdAt,
      Value<DateTime?> lastCheckedAt,
      Value<int> rowid,
    });

class $$SubscriptionsTableFilterComposer
    extends Composer<_$MewsDatabase, $SubscriptionsTable> {
  $$SubscriptionsTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get url => $composableBuilder(
    column: $table.url,
    builder: (column) => ColumnFilters(column),
  );

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

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

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

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

class $$SubscriptionsTableOrderingComposer
    extends Composer<_$MewsDatabase, $SubscriptionsTable> {
  $$SubscriptionsTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get url => $composableBuilder(
    column: $table.url,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

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

class $$SubscriptionsTableAnnotationComposer
    extends Composer<_$MewsDatabase, $SubscriptionsTable> {
  $$SubscriptionsTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get url =>
      $composableBuilder(column: $table.url, builder: (column) => column);

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

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

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

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

class $$SubscriptionsTableTableManager
    extends
        RootTableManager<
          _$MewsDatabase,
          $SubscriptionsTable,
          Subscription,
          $$SubscriptionsTableFilterComposer,
          $$SubscriptionsTableOrderingComposer,
          $$SubscriptionsTableAnnotationComposer,
          $$SubscriptionsTableCreateCompanionBuilder,
          $$SubscriptionsTableUpdateCompanionBuilder,
          (
            Subscription,
            BaseReferences<_$MewsDatabase, $SubscriptionsTable, Subscription>,
          ),
          Subscription,
          PrefetchHooks Function()
        > {
  $$SubscriptionsTableTableManager(_$MewsDatabase db, $SubscriptionsTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$SubscriptionsTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$SubscriptionsTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$SubscriptionsTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> url = const Value.absent(),
                Value<String?> title = const Value.absent(),
                Value<String?> atomHref = const Value.absent(),
                Value<DateTime> createdAt = const Value.absent(),
                Value<DateTime?> lastCheckedAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => SubscriptionsCompanion(
                url: url,
                title: title,
                atomHref: atomHref,
                createdAt: createdAt,
                lastCheckedAt: lastCheckedAt,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String url,
                Value<String?> title = const Value.absent(),
                Value<String?> atomHref = const Value.absent(),
                Value<DateTime> createdAt = const Value.absent(),
                Value<DateTime?> lastCheckedAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => SubscriptionsCompanion.insert(
                url: url,
                title: title,
                atomHref: atomHref,
                createdAt: createdAt,
                lastCheckedAt: lastCheckedAt,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$SubscriptionsTableProcessedTableManager =
    ProcessedTableManager<
      _$MewsDatabase,
      $SubscriptionsTable,
      Subscription,
      $$SubscriptionsTableFilterComposer,
      $$SubscriptionsTableOrderingComposer,
      $$SubscriptionsTableAnnotationComposer,
      $$SubscriptionsTableCreateCompanionBuilder,
      $$SubscriptionsTableUpdateCompanionBuilder,
      (
        Subscription,
        BaseReferences<_$MewsDatabase, $SubscriptionsTable, Subscription>,
      ),
      Subscription,
      PrefetchHooks Function()
    >;
typedef $$FeedEntriesTableCreateCompanionBuilder =
    FeedEntriesCompanion Function({
      required String siteUrl,
      required String url,
      required String title,
      required DateTime date,
      Value<DateTime> foundAt,
      Value<DateTime?> readAt,
      Value<int> rowid,
    });
typedef $$FeedEntriesTableUpdateCompanionBuilder =
    FeedEntriesCompanion Function({
      Value<String> siteUrl,
      Value<String> url,
      Value<String> title,
      Value<DateTime> date,
      Value<DateTime> foundAt,
      Value<DateTime?> readAt,
      Value<int> rowid,
    });

class $$FeedEntriesTableFilterComposer
    extends Composer<_$MewsDatabase, $FeedEntriesTable> {
  $$FeedEntriesTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get siteUrl => $composableBuilder(
    column: $table.siteUrl,
    builder: (column) => ColumnFilters(column),
  );

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

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

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

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

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

class $$FeedEntriesTableOrderingComposer
    extends Composer<_$MewsDatabase, $FeedEntriesTable> {
  $$FeedEntriesTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get siteUrl => $composableBuilder(
    column: $table.siteUrl,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

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

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

class $$FeedEntriesTableAnnotationComposer
    extends Composer<_$MewsDatabase, $FeedEntriesTable> {
  $$FeedEntriesTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get siteUrl =>
      $composableBuilder(column: $table.siteUrl, builder: (column) => column);

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

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

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

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

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

class $$FeedEntriesTableTableManager
    extends
        RootTableManager<
          _$MewsDatabase,
          $FeedEntriesTable,
          FeedEntry,
          $$FeedEntriesTableFilterComposer,
          $$FeedEntriesTableOrderingComposer,
          $$FeedEntriesTableAnnotationComposer,
          $$FeedEntriesTableCreateCompanionBuilder,
          $$FeedEntriesTableUpdateCompanionBuilder,
          (
            FeedEntry,
            BaseReferences<_$MewsDatabase, $FeedEntriesTable, FeedEntry>,
          ),
          FeedEntry,
          PrefetchHooks Function()
        > {
  $$FeedEntriesTableTableManager(_$MewsDatabase db, $FeedEntriesTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$FeedEntriesTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$FeedEntriesTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$FeedEntriesTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> siteUrl = const Value.absent(),
                Value<String> url = const Value.absent(),
                Value<String> title = const Value.absent(),
                Value<DateTime> date = const Value.absent(),
                Value<DateTime> foundAt = const Value.absent(),
                Value<DateTime?> readAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => FeedEntriesCompanion(
                siteUrl: siteUrl,
                url: url,
                title: title,
                date: date,
                foundAt: foundAt,
                readAt: readAt,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String siteUrl,
                required String url,
                required String title,
                required DateTime date,
                Value<DateTime> foundAt = const Value.absent(),
                Value<DateTime?> readAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => FeedEntriesCompanion.insert(
                siteUrl: siteUrl,
                url: url,
                title: title,
                date: date,
                foundAt: foundAt,
                readAt: readAt,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$FeedEntriesTableProcessedTableManager =
    ProcessedTableManager<
      _$MewsDatabase,
      $FeedEntriesTable,
      FeedEntry,
      $$FeedEntriesTableFilterComposer,
      $$FeedEntriesTableOrderingComposer,
      $$FeedEntriesTableAnnotationComposer,
      $$FeedEntriesTableCreateCompanionBuilder,
      $$FeedEntriesTableUpdateCompanionBuilder,
      (FeedEntry, BaseReferences<_$MewsDatabase, $FeedEntriesTable, FeedEntry>),
      FeedEntry,
      PrefetchHooks Function()
    >;
typedef $$ItemTagsTableCreateCompanionBuilder =
    ItemTagsCompanion Function({
      required TagKind kind,
      required String url,
      required String tag,
      Value<DateTime> createdAt,
      Value<int> rowid,
    });
typedef $$ItemTagsTableUpdateCompanionBuilder =
    ItemTagsCompanion Function({
      Value<TagKind> kind,
      Value<String> url,
      Value<String> tag,
      Value<DateTime> createdAt,
      Value<int> rowid,
    });

class $$ItemTagsTableFilterComposer
    extends Composer<_$MewsDatabase, $ItemTagsTable> {
  $$ItemTagsTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnWithTypeConverterFilters<TagKind, TagKind, String> get kind =>
      $composableBuilder(
        column: $table.kind,
        builder: (column) => ColumnWithTypeConverterFilters(column),
      );

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

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

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

class $$ItemTagsTableOrderingComposer
    extends Composer<_$MewsDatabase, $ItemTagsTable> {
  $$ItemTagsTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get kind => $composableBuilder(
    column: $table.kind,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

class $$ItemTagsTableAnnotationComposer
    extends Composer<_$MewsDatabase, $ItemTagsTable> {
  $$ItemTagsTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumnWithTypeConverter<TagKind, String> get kind =>
      $composableBuilder(column: $table.kind, builder: (column) => column);

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

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

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

class $$ItemTagsTableTableManager
    extends
        RootTableManager<
          _$MewsDatabase,
          $ItemTagsTable,
          ItemTag,
          $$ItemTagsTableFilterComposer,
          $$ItemTagsTableOrderingComposer,
          $$ItemTagsTableAnnotationComposer,
          $$ItemTagsTableCreateCompanionBuilder,
          $$ItemTagsTableUpdateCompanionBuilder,
          (ItemTag, BaseReferences<_$MewsDatabase, $ItemTagsTable, ItemTag>),
          ItemTag,
          PrefetchHooks Function()
        > {
  $$ItemTagsTableTableManager(_$MewsDatabase db, $ItemTagsTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$ItemTagsTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$ItemTagsTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$ItemTagsTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<TagKind> kind = const Value.absent(),
                Value<String> url = const Value.absent(),
                Value<String> tag = const Value.absent(),
                Value<DateTime> createdAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => ItemTagsCompanion(
                kind: kind,
                url: url,
                tag: tag,
                createdAt: createdAt,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required TagKind kind,
                required String url,
                required String tag,
                Value<DateTime> createdAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => ItemTagsCompanion.insert(
                kind: kind,
                url: url,
                tag: tag,
                createdAt: createdAt,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$ItemTagsTableProcessedTableManager =
    ProcessedTableManager<
      _$MewsDatabase,
      $ItemTagsTable,
      ItemTag,
      $$ItemTagsTableFilterComposer,
      $$ItemTagsTableOrderingComposer,
      $$ItemTagsTableAnnotationComposer,
      $$ItemTagsTableCreateCompanionBuilder,
      $$ItemTagsTableUpdateCompanionBuilder,
      (ItemTag, BaseReferences<_$MewsDatabase, $ItemTagsTable, ItemTag>),
      ItemTag,
      PrefetchHooks Function()
    >;
typedef $$ReaderSettingsTableCreateCompanionBuilder =
    ReaderSettingsCompanion Function({
      Value<int> id,
      Value<String> font,
      Value<double> fontScale,
      Value<String> themeMode,
      Value<String> variant,
      Value<String> language,
    });
typedef $$ReaderSettingsTableUpdateCompanionBuilder =
    ReaderSettingsCompanion Function({
      Value<int> id,
      Value<String> font,
      Value<double> fontScale,
      Value<String> themeMode,
      Value<String> variant,
      Value<String> language,
    });

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class $$ReaderSettingsTableTableManager
    extends
        RootTableManager<
          _$MewsDatabase,
          $ReaderSettingsTable,
          ReaderSetting,
          $$ReaderSettingsTableFilterComposer,
          $$ReaderSettingsTableOrderingComposer,
          $$ReaderSettingsTableAnnotationComposer,
          $$ReaderSettingsTableCreateCompanionBuilder,
          $$ReaderSettingsTableUpdateCompanionBuilder,
          (
            ReaderSetting,
            BaseReferences<_$MewsDatabase, $ReaderSettingsTable, ReaderSetting>,
          ),
          ReaderSetting,
          PrefetchHooks Function()
        > {
  $$ReaderSettingsTableTableManager(
    _$MewsDatabase db,
    $ReaderSettingsTable table,
  ) : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$ReaderSettingsTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$ReaderSettingsTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$ReaderSettingsTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                Value<String> font = const Value.absent(),
                Value<double> fontScale = const Value.absent(),
                Value<String> themeMode = const Value.absent(),
                Value<String> variant = const Value.absent(),
                Value<String> language = const Value.absent(),
              }) => ReaderSettingsCompanion(
                id: id,
                font: font,
                fontScale: fontScale,
                themeMode: themeMode,
                variant: variant,
                language: language,
              ),
          createCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                Value<String> font = const Value.absent(),
                Value<double> fontScale = const Value.absent(),
                Value<String> themeMode = const Value.absent(),
                Value<String> variant = const Value.absent(),
                Value<String> language = const Value.absent(),
              }) => ReaderSettingsCompanion.insert(
                id: id,
                font: font,
                fontScale: fontScale,
                themeMode: themeMode,
                variant: variant,
                language: language,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$ReaderSettingsTableProcessedTableManager =
    ProcessedTableManager<
      _$MewsDatabase,
      $ReaderSettingsTable,
      ReaderSetting,
      $$ReaderSettingsTableFilterComposer,
      $$ReaderSettingsTableOrderingComposer,
      $$ReaderSettingsTableAnnotationComposer,
      $$ReaderSettingsTableCreateCompanionBuilder,
      $$ReaderSettingsTableUpdateCompanionBuilder,
      (
        ReaderSetting,
        BaseReferences<_$MewsDatabase, $ReaderSettingsTable, ReaderSetting>,
      ),
      ReaderSetting,
      PrefetchHooks Function()
    >;
typedef $$CachedPagesTableCreateCompanionBuilder =
    CachedPagesCompanion Function({
      required String url,
      Value<String?> title,
      required String source,
      Value<String?> etag,
      Value<String?> lastModified,
      Value<DateTime> cachedAt,
      Value<int> rowid,
    });
typedef $$CachedPagesTableUpdateCompanionBuilder =
    CachedPagesCompanion Function({
      Value<String> url,
      Value<String?> title,
      Value<String> source,
      Value<String?> etag,
      Value<String?> lastModified,
      Value<DateTime> cachedAt,
      Value<int> rowid,
    });

class $$CachedPagesTableFilterComposer
    extends Composer<_$MewsDatabase, $CachedPagesTable> {
  $$CachedPagesTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get url => $composableBuilder(
    column: $table.url,
    builder: (column) => ColumnFilters(column),
  );

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

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

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

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

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

class $$CachedPagesTableOrderingComposer
    extends Composer<_$MewsDatabase, $CachedPagesTable> {
  $$CachedPagesTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get url => $composableBuilder(
    column: $table.url,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

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

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

class $$CachedPagesTableAnnotationComposer
    extends Composer<_$MewsDatabase, $CachedPagesTable> {
  $$CachedPagesTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get url =>
      $composableBuilder(column: $table.url, builder: (column) => column);

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

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

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

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

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

class $$CachedPagesTableTableManager
    extends
        RootTableManager<
          _$MewsDatabase,
          $CachedPagesTable,
          CachedPage,
          $$CachedPagesTableFilterComposer,
          $$CachedPagesTableOrderingComposer,
          $$CachedPagesTableAnnotationComposer,
          $$CachedPagesTableCreateCompanionBuilder,
          $$CachedPagesTableUpdateCompanionBuilder,
          (
            CachedPage,
            BaseReferences<_$MewsDatabase, $CachedPagesTable, CachedPage>,
          ),
          CachedPage,
          PrefetchHooks Function()
        > {
  $$CachedPagesTableTableManager(_$MewsDatabase db, $CachedPagesTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$CachedPagesTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$CachedPagesTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$CachedPagesTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> url = const Value.absent(),
                Value<String?> title = const Value.absent(),
                Value<String> source = const Value.absent(),
                Value<String?> etag = const Value.absent(),
                Value<String?> lastModified = const Value.absent(),
                Value<DateTime> cachedAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => CachedPagesCompanion(
                url: url,
                title: title,
                source: source,
                etag: etag,
                lastModified: lastModified,
                cachedAt: cachedAt,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String url,
                Value<String?> title = const Value.absent(),
                required String source,
                Value<String?> etag = const Value.absent(),
                Value<String?> lastModified = const Value.absent(),
                Value<DateTime> cachedAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => CachedPagesCompanion.insert(
                url: url,
                title: title,
                source: source,
                etag: etag,
                lastModified: lastModified,
                cachedAt: cachedAt,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$CachedPagesTableProcessedTableManager =
    ProcessedTableManager<
      _$MewsDatabase,
      $CachedPagesTable,
      CachedPage,
      $$CachedPagesTableFilterComposer,
      $$CachedPagesTableOrderingComposer,
      $$CachedPagesTableAnnotationComposer,
      $$CachedPagesTableCreateCompanionBuilder,
      $$CachedPagesTableUpdateCompanionBuilder,
      (
        CachedPage,
        BaseReferences<_$MewsDatabase, $CachedPagesTable, CachedPage>,
      ),
      CachedPage,
      PrefetchHooks Function()
    >;
typedef $$KnownHostsTableCreateCompanionBuilder =
    KnownHostsCompanion Function({
      required String host,
      required int port,
      required String fingerprint,
      required DateTime expires,
      Value<DateTime> pinnedAt,
      Value<int> rowid,
    });
typedef $$KnownHostsTableUpdateCompanionBuilder =
    KnownHostsCompanion Function({
      Value<String> host,
      Value<int> port,
      Value<String> fingerprint,
      Value<DateTime> expires,
      Value<DateTime> pinnedAt,
      Value<int> rowid,
    });

class $$KnownHostsTableFilterComposer
    extends Composer<_$MewsDatabase, $KnownHostsTable> {
  $$KnownHostsTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get host => $composableBuilder(
    column: $table.host,
    builder: (column) => ColumnFilters(column),
  );

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

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

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

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

class $$KnownHostsTableOrderingComposer
    extends Composer<_$MewsDatabase, $KnownHostsTable> {
  $$KnownHostsTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get host => $composableBuilder(
    column: $table.host,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

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

class $$KnownHostsTableAnnotationComposer
    extends Composer<_$MewsDatabase, $KnownHostsTable> {
  $$KnownHostsTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get host =>
      $composableBuilder(column: $table.host, builder: (column) => column);

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

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

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

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

class $$KnownHostsTableTableManager
    extends
        RootTableManager<
          _$MewsDatabase,
          $KnownHostsTable,
          KnownHost,
          $$KnownHostsTableFilterComposer,
          $$KnownHostsTableOrderingComposer,
          $$KnownHostsTableAnnotationComposer,
          $$KnownHostsTableCreateCompanionBuilder,
          $$KnownHostsTableUpdateCompanionBuilder,
          (
            KnownHost,
            BaseReferences<_$MewsDatabase, $KnownHostsTable, KnownHost>,
          ),
          KnownHost,
          PrefetchHooks Function()
        > {
  $$KnownHostsTableTableManager(_$MewsDatabase db, $KnownHostsTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$KnownHostsTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$KnownHostsTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$KnownHostsTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> host = const Value.absent(),
                Value<int> port = const Value.absent(),
                Value<String> fingerprint = const Value.absent(),
                Value<DateTime> expires = const Value.absent(),
                Value<DateTime> pinnedAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => KnownHostsCompanion(
                host: host,
                port: port,
                fingerprint: fingerprint,
                expires: expires,
                pinnedAt: pinnedAt,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String host,
                required int port,
                required String fingerprint,
                required DateTime expires,
                Value<DateTime> pinnedAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => KnownHostsCompanion.insert(
                host: host,
                port: port,
                fingerprint: fingerprint,
                expires: expires,
                pinnedAt: pinnedAt,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$KnownHostsTableProcessedTableManager =
    ProcessedTableManager<
      _$MewsDatabase,
      $KnownHostsTable,
      KnownHost,
      $$KnownHostsTableFilterComposer,
      $$KnownHostsTableOrderingComposer,
      $$KnownHostsTableAnnotationComposer,
      $$KnownHostsTableCreateCompanionBuilder,
      $$KnownHostsTableUpdateCompanionBuilder,
      (KnownHost, BaseReferences<_$MewsDatabase, $KnownHostsTable, KnownHost>),
      KnownHost,
      PrefetchHooks Function()
    >;
typedef $$ClientCertificatesTableCreateCompanionBuilder =
    ClientCertificatesCompanion Function({
      Value<int> id,
      required String name,
      required String certPem,
      Value<DateTime> createdAt,
    });
typedef $$ClientCertificatesTableUpdateCompanionBuilder =
    ClientCertificatesCompanion Function({
      Value<int> id,
      Value<String> name,
      Value<String> certPem,
      Value<DateTime> createdAt,
    });

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

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

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

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

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

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

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

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

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

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

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

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

class $$ClientCertificatesTableTableManager
    extends
        RootTableManager<
          _$MewsDatabase,
          $ClientCertificatesTable,
          ClientCertificate,
          $$ClientCertificatesTableFilterComposer,
          $$ClientCertificatesTableOrderingComposer,
          $$ClientCertificatesTableAnnotationComposer,
          $$ClientCertificatesTableCreateCompanionBuilder,
          $$ClientCertificatesTableUpdateCompanionBuilder,
          (
            ClientCertificate,
            BaseReferences<
              _$MewsDatabase,
              $ClientCertificatesTable,
              ClientCertificate
            >,
          ),
          ClientCertificate,
          PrefetchHooks Function()
        > {
  $$ClientCertificatesTableTableManager(
    _$MewsDatabase db,
    $ClientCertificatesTable table,
  ) : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$ClientCertificatesTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$ClientCertificatesTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$ClientCertificatesTableAnnotationComposer(
                $db: db,
                $table: table,
              ),
          updateCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                Value<String> name = const Value.absent(),
                Value<String> certPem = const Value.absent(),
                Value<DateTime> createdAt = const Value.absent(),
              }) => ClientCertificatesCompanion(
                id: id,
                name: name,
                certPem: certPem,
                createdAt: createdAt,
              ),
          createCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                required String name,
                required String certPem,
                Value<DateTime> createdAt = const Value.absent(),
              }) => ClientCertificatesCompanion.insert(
                id: id,
                name: name,
                certPem: certPem,
                createdAt: createdAt,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$ClientCertificatesTableProcessedTableManager =
    ProcessedTableManager<
      _$MewsDatabase,
      $ClientCertificatesTable,
      ClientCertificate,
      $$ClientCertificatesTableFilterComposer,
      $$ClientCertificatesTableOrderingComposer,
      $$ClientCertificatesTableAnnotationComposer,
      $$ClientCertificatesTableCreateCompanionBuilder,
      $$ClientCertificatesTableUpdateCompanionBuilder,
      (
        ClientCertificate,
        BaseReferences<
          _$MewsDatabase,
          $ClientCertificatesTable,
          ClientCertificate
        >,
      ),
      ClientCertificate,
      PrefetchHooks Function()
    >;
typedef $$SiteCertificatesTableCreateCompanionBuilder =
    SiteCertificatesCompanion Function({
      required String host,
      required int port,
      required int certificateId,
      Value<int> rowid,
    });
typedef $$SiteCertificatesTableUpdateCompanionBuilder =
    SiteCertificatesCompanion Function({
      Value<String> host,
      Value<int> port,
      Value<int> certificateId,
      Value<int> rowid,
    });

class $$SiteCertificatesTableFilterComposer
    extends Composer<_$MewsDatabase, $SiteCertificatesTable> {
  $$SiteCertificatesTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get host => $composableBuilder(
    column: $table.host,
    builder: (column) => ColumnFilters(column),
  );

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

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

class $$SiteCertificatesTableOrderingComposer
    extends Composer<_$MewsDatabase, $SiteCertificatesTable> {
  $$SiteCertificatesTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get host => $composableBuilder(
    column: $table.host,
    builder: (column) => ColumnOrderings(column),
  );

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

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

class $$SiteCertificatesTableAnnotationComposer
    extends Composer<_$MewsDatabase, $SiteCertificatesTable> {
  $$SiteCertificatesTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get host =>
      $composableBuilder(column: $table.host, builder: (column) => column);

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

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

class $$SiteCertificatesTableTableManager
    extends
        RootTableManager<
          _$MewsDatabase,
          $SiteCertificatesTable,
          SiteCertificate,
          $$SiteCertificatesTableFilterComposer,
          $$SiteCertificatesTableOrderingComposer,
          $$SiteCertificatesTableAnnotationComposer,
          $$SiteCertificatesTableCreateCompanionBuilder,
          $$SiteCertificatesTableUpdateCompanionBuilder,
          (
            SiteCertificate,
            BaseReferences<
              _$MewsDatabase,
              $SiteCertificatesTable,
              SiteCertificate
            >,
          ),
          SiteCertificate,
          PrefetchHooks Function()
        > {
  $$SiteCertificatesTableTableManager(
    _$MewsDatabase db,
    $SiteCertificatesTable table,
  ) : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$SiteCertificatesTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$SiteCertificatesTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$SiteCertificatesTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> host = const Value.absent(),
                Value<int> port = const Value.absent(),
                Value<int> certificateId = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => SiteCertificatesCompanion(
                host: host,
                port: port,
                certificateId: certificateId,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String host,
                required int port,
                required int certificateId,
                Value<int> rowid = const Value.absent(),
              }) => SiteCertificatesCompanion.insert(
                host: host,
                port: port,
                certificateId: certificateId,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$SiteCertificatesTableProcessedTableManager =
    ProcessedTableManager<
      _$MewsDatabase,
      $SiteCertificatesTable,
      SiteCertificate,
      $$SiteCertificatesTableFilterComposer,
      $$SiteCertificatesTableOrderingComposer,
      $$SiteCertificatesTableAnnotationComposer,
      $$SiteCertificatesTableCreateCompanionBuilder,
      $$SiteCertificatesTableUpdateCompanionBuilder,
      (
        SiteCertificate,
        BaseReferences<_$MewsDatabase, $SiteCertificatesTable, SiteCertificate>,
      ),
      SiteCertificate,
      PrefetchHooks Function()
    >;
typedef $$FirstStartTableCreateCompanionBuilder =
    FirstStartCompanion Function({Value<int> id, Value<bool> directorySeeded});
typedef $$FirstStartTableUpdateCompanionBuilder =
    FirstStartCompanion Function({Value<int> id, Value<bool> directorySeeded});

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

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

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

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

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

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

class $$FirstStartTableTableManager
    extends
        RootTableManager<
          _$MewsDatabase,
          $FirstStartTable,
          FirstStartData,
          $$FirstStartTableFilterComposer,
          $$FirstStartTableOrderingComposer,
          $$FirstStartTableAnnotationComposer,
          $$FirstStartTableCreateCompanionBuilder,
          $$FirstStartTableUpdateCompanionBuilder,
          (
            FirstStartData,
            BaseReferences<_$MewsDatabase, $FirstStartTable, FirstStartData>,
          ),
          FirstStartData,
          PrefetchHooks Function()
        > {
  $$FirstStartTableTableManager(_$MewsDatabase db, $FirstStartTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$FirstStartTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$FirstStartTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$FirstStartTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                Value<bool> directorySeeded = const Value.absent(),
              }) =>
                  FirstStartCompanion(id: id, directorySeeded: directorySeeded),
          createCompanionCallback:
              ({
                Value<int> id = const Value.absent(),
                Value<bool> directorySeeded = const Value.absent(),
              }) => FirstStartCompanion.insert(
                id: id,
                directorySeeded: directorySeeded,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$FirstStartTableProcessedTableManager =
    ProcessedTableManager<
      _$MewsDatabase,
      $FirstStartTable,
      FirstStartData,
      $$FirstStartTableFilterComposer,
      $$FirstStartTableOrderingComposer,
      $$FirstStartTableAnnotationComposer,
      $$FirstStartTableCreateCompanionBuilder,
      $$FirstStartTableUpdateCompanionBuilder,
      (
        FirstStartData,
        BaseReferences<_$MewsDatabase, $FirstStartTable, FirstStartData>,
      ),
      FirstStartData,
      PrefetchHooks Function()
    >;

class $MewsDatabaseManager {
  final _$MewsDatabase _db;
  $MewsDatabaseManager(this._db);
  $$HistoryItemsTableTableManager get historyItems =>
      $$HistoryItemsTableTableManager(_db, _db.historyItems);
  $$BookmarksTableTableManager get bookmarks =>
      $$BookmarksTableTableManager(_db, _db.bookmarks);
  $$SubscriptionsTableTableManager get subscriptions =>
      $$SubscriptionsTableTableManager(_db, _db.subscriptions);
  $$FeedEntriesTableTableManager get feedEntries =>
      $$FeedEntriesTableTableManager(_db, _db.feedEntries);
  $$ItemTagsTableTableManager get itemTags =>
      $$ItemTagsTableTableManager(_db, _db.itemTags);
  $$ReaderSettingsTableTableManager get readerSettings =>
      $$ReaderSettingsTableTableManager(_db, _db.readerSettings);
  $$CachedPagesTableTableManager get cachedPages =>
      $$CachedPagesTableTableManager(_db, _db.cachedPages);
  $$KnownHostsTableTableManager get knownHosts =>
      $$KnownHostsTableTableManager(_db, _db.knownHosts);
  $$ClientCertificatesTableTableManager get clientCertificates =>
      $$ClientCertificatesTableTableManager(_db, _db.clientCertificates);
  $$SiteCertificatesTableTableManager get siteCertificates =>
      $$SiteCertificatesTableTableManager(_db, _db.siteCertificates);
  $$FirstStartTableTableManager get firstStart =>
      $$FirstStartTableTableManager(_db, _db.firstStart);
}