// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'database.dart';

// ignore_for_file: type=lint
class BangTable extends Table with TableInfo<BangTable, Bang> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  BangTable(this.attachedDatabase, [this._alias]);
  late final GeneratedColumn<String> trigger = GeneratedColumn<String>(
    'trigger',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    $customConstraints: 'PRIMARY KEY NOT NULL',
  );
  late final GeneratedColumnWithTypeConverter<BangGroup, int> group =
      GeneratedColumn<int>(
        'group',
        aliasedName,
        false,
        type: DriftSqlType.int,
        requiredDuringInsert: true,
        $customConstraints: 'NOT NULL',
      ).withConverter<BangGroup>(BangTable.$convertergroup);
  late final GeneratedColumn<String> websiteName = GeneratedColumn<String>(
    'website_name',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    $customConstraints: 'NOT NULL',
  );
  late final GeneratedColumn<String> domain = GeneratedColumn<String>(
    'domain',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    $customConstraints: 'NOT NULL',
  );
  late final GeneratedColumn<String> urlTemplate = GeneratedColumn<String>(
    'url_template',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    $customConstraints: 'NOT NULL',
  );
  late final GeneratedColumn<String> category = GeneratedColumn<String>(
    'category',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    $customConstraints: '',
  );
  late final GeneratedColumn<String> subCategory = GeneratedColumn<String>(
    'sub_category',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    $customConstraints: '',
  );
  late final GeneratedColumnWithTypeConverter<Set<BangFormat>?, String> format =
      GeneratedColumn<String>(
        'format',
        aliasedName,
        true,
        type: DriftSqlType.string,
        requiredDuringInsert: false,
        $customConstraints: '',
      ).withConverter<Set<BangFormat>?>(BangTable.$converterformat);
  @override
  List<GeneratedColumn> get $columns => [
    trigger,
    group,
    websiteName,
    domain,
    urlTemplate,
    category,
    subCategory,
    format,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'bang';
  @override
  Set<GeneratedColumn> get $primaryKey => {trigger};
  @override
  Bang map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return Bang(
      websiteName:
          attachedDatabase.typeMapping.read(
            DriftSqlType.string,
            data['${effectivePrefix}website_name'],
          )!,
      domain:
          attachedDatabase.typeMapping.read(
            DriftSqlType.string,
            data['${effectivePrefix}domain'],
          )!,
      trigger:
          attachedDatabase.typeMapping.read(
            DriftSqlType.string,
            data['${effectivePrefix}trigger'],
          )!,
      urlTemplate:
          attachedDatabase.typeMapping.read(
            DriftSqlType.string,
            data['${effectivePrefix}url_template'],
          )!,
      group: BangTable.$convertergroup.fromSql(
        attachedDatabase.typeMapping.read(
          DriftSqlType.int,
          data['${effectivePrefix}group'],
        )!,
      ),
      category: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}category'],
      ),
      subCategory: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}sub_category'],
      ),
      format: BangTable.$converterformat.fromSql(
        attachedDatabase.typeMapping.read(
          DriftSqlType.string,
          data['${effectivePrefix}format'],
        ),
      ),
    );
  }

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

  static JsonTypeConverter2<BangGroup, int, int> $convertergroup =
      const EnumIndexConverter<BangGroup>(BangGroup.values);
  static TypeConverter<Set<BangFormat>?, String?> $converterformat =
      const BangFormatConverter();
  @override
  bool get dontWriteConstraints => true;
}

class BangCompanion extends UpdateCompanion<Bang> {
  final Value<String> trigger;
  final Value<BangGroup> group;
  final Value<String> websiteName;
  final Value<String> domain;
  final Value<String> urlTemplate;
  final Value<String?> category;
  final Value<String?> subCategory;
  final Value<Set<BangFormat>?> format;
  final Value<int> rowid;
  const BangCompanion({
    this.trigger = const Value.absent(),
    this.group = const Value.absent(),
    this.websiteName = const Value.absent(),
    this.domain = const Value.absent(),
    this.urlTemplate = const Value.absent(),
    this.category = const Value.absent(),
    this.subCategory = const Value.absent(),
    this.format = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  BangCompanion.insert({
    required String trigger,
    required BangGroup group,
    required String websiteName,
    required String domain,
    required String urlTemplate,
    this.category = const Value.absent(),
    this.subCategory = const Value.absent(),
    this.format = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : trigger = Value(trigger),
       group = Value(group),
       websiteName = Value(websiteName),
       domain = Value(domain),
       urlTemplate = Value(urlTemplate);
  static Insertable<Bang> custom({
    Expression<String>? trigger,
    Expression<int>? group,
    Expression<String>? websiteName,
    Expression<String>? domain,
    Expression<String>? urlTemplate,
    Expression<String>? category,
    Expression<String>? subCategory,
    Expression<String>? format,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (trigger != null) 'trigger': trigger,
      if (group != null) 'group': group,
      if (websiteName != null) 'website_name': websiteName,
      if (domain != null) 'domain': domain,
      if (urlTemplate != null) 'url_template': urlTemplate,
      if (category != null) 'category': category,
      if (subCategory != null) 'sub_category': subCategory,
      if (format != null) 'format': format,
      if (rowid != null) 'rowid': rowid,
    });
  }

  BangCompanion copyWith({
    Value<String>? trigger,
    Value<BangGroup>? group,
    Value<String>? websiteName,
    Value<String>? domain,
    Value<String>? urlTemplate,
    Value<String?>? category,
    Value<String?>? subCategory,
    Value<Set<BangFormat>?>? format,
    Value<int>? rowid,
  }) {
    return BangCompanion(
      trigger: trigger ?? this.trigger,
      group: group ?? this.group,
      websiteName: websiteName ?? this.websiteName,
      domain: domain ?? this.domain,
      urlTemplate: urlTemplate ?? this.urlTemplate,
      category: category ?? this.category,
      subCategory: subCategory ?? this.subCategory,
      format: format ?? this.format,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (trigger.present) {
      map['trigger'] = Variable<String>(trigger.value);
    }
    if (group.present) {
      map['group'] = Variable<int>(
        BangTable.$convertergroup.toSql(group.value),
      );
    }
    if (websiteName.present) {
      map['website_name'] = Variable<String>(websiteName.value);
    }
    if (domain.present) {
      map['domain'] = Variable<String>(domain.value);
    }
    if (urlTemplate.present) {
      map['url_template'] = Variable<String>(urlTemplate.value);
    }
    if (category.present) {
      map['category'] = Variable<String>(category.value);
    }
    if (subCategory.present) {
      map['sub_category'] = Variable<String>(subCategory.value);
    }
    if (format.present) {
      map['format'] = Variable<String>(
        BangTable.$converterformat.toSql(format.value),
      );
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('BangCompanion(')
          ..write('trigger: $trigger, ')
          ..write('group: $group, ')
          ..write('websiteName: $websiteName, ')
          ..write('domain: $domain, ')
          ..write('urlTemplate: $urlTemplate, ')
          ..write('category: $category, ')
          ..write('subCategory: $subCategory, ')
          ..write('format: $format, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class BangSync extends Table with TableInfo<BangSync, BangSyncData> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  BangSync(this.attachedDatabase, [this._alias]);
  late final GeneratedColumnWithTypeConverter<BangGroup, int> group =
      GeneratedColumn<int>(
        'group',
        aliasedName,
        false,
        type: DriftSqlType.int,
        requiredDuringInsert: false,
        $customConstraints: 'PRIMARY KEY NOT NULL',
      ).withConverter<BangGroup>(BangSync.$convertergroup);
  late final GeneratedColumn<DateTime> lastSync = GeneratedColumn<DateTime>(
    'last_sync',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: true,
    $customConstraints: 'NOT NULL',
  );
  @override
  List<GeneratedColumn> get $columns => [group, lastSync];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'bang_sync';
  @override
  Set<GeneratedColumn> get $primaryKey => {group};
  @override
  BangSyncData map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return BangSyncData(
      group: BangSync.$convertergroup.fromSql(
        attachedDatabase.typeMapping.read(
          DriftSqlType.int,
          data['${effectivePrefix}group'],
        )!,
      ),
      lastSync:
          attachedDatabase.typeMapping.read(
            DriftSqlType.dateTime,
            data['${effectivePrefix}last_sync'],
          )!,
    );
  }

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

  static JsonTypeConverter2<BangGroup, int, int> $convertergroup =
      const EnumIndexConverter<BangGroup>(BangGroup.values);
  @override
  bool get dontWriteConstraints => true;
}

class BangSyncData extends DataClass implements Insertable<BangSyncData> {
  final BangGroup group;
  final DateTime lastSync;
  const BangSyncData({required this.group, required this.lastSync});
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    {
      map['group'] = Variable<int>(BangSync.$convertergroup.toSql(group));
    }
    map['last_sync'] = Variable<DateTime>(lastSync);
    return map;
  }

  factory BangSyncData.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return BangSyncData(
      group: BangSync.$convertergroup.fromJson(
        serializer.fromJson<int>(json['group']),
      ),
      lastSync: serializer.fromJson<DateTime>(json['last_sync']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'group': serializer.toJson<int>(BangSync.$convertergroup.toJson(group)),
      'last_sync': serializer.toJson<DateTime>(lastSync),
    };
  }

  BangSyncData copyWith({BangGroup? group, DateTime? lastSync}) => BangSyncData(
    group: group ?? this.group,
    lastSync: lastSync ?? this.lastSync,
  );
  BangSyncData copyWithCompanion(BangSyncCompanion data) {
    return BangSyncData(
      group: data.group.present ? data.group.value : this.group,
      lastSync: data.lastSync.present ? data.lastSync.value : this.lastSync,
    );
  }

  @override
  String toString() {
    return (StringBuffer('BangSyncData(')
          ..write('group: $group, ')
          ..write('lastSync: $lastSync')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(group, lastSync);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is BangSyncData &&
          other.group == this.group &&
          other.lastSync == this.lastSync);
}

class BangSyncCompanion extends UpdateCompanion<BangSyncData> {
  final Value<BangGroup> group;
  final Value<DateTime> lastSync;
  const BangSyncCompanion({
    this.group = const Value.absent(),
    this.lastSync = const Value.absent(),
  });
  BangSyncCompanion.insert({
    this.group = const Value.absent(),
    required DateTime lastSync,
  }) : lastSync = Value(lastSync);
  static Insertable<BangSyncData> custom({
    Expression<int>? group,
    Expression<DateTime>? lastSync,
  }) {
    return RawValuesInsertable({
      if (group != null) 'group': group,
      if (lastSync != null) 'last_sync': lastSync,
    });
  }

  BangSyncCompanion copyWith({
    Value<BangGroup>? group,
    Value<DateTime>? lastSync,
  }) {
    return BangSyncCompanion(
      group: group ?? this.group,
      lastSync: lastSync ?? this.lastSync,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (group.present) {
      map['group'] = Variable<int>(BangSync.$convertergroup.toSql(group.value));
    }
    if (lastSync.present) {
      map['last_sync'] = Variable<DateTime>(lastSync.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('BangSyncCompanion(')
          ..write('group: $group, ')
          ..write('lastSync: $lastSync')
          ..write(')'))
        .toString();
  }
}

class BangFrequency extends Table
    with TableInfo<BangFrequency, BangFrequencyData> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  BangFrequency(this.attachedDatabase, [this._alias]);
  late final GeneratedColumn<String> trigger = GeneratedColumn<String>(
    'trigger',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    $customConstraints:
        'PRIMARY KEY NOT NULL REFERENCES bang("trigger")ON DELETE CASCADE',
  );
  late final GeneratedColumn<int> frequency = GeneratedColumn<int>(
    'frequency',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
    $customConstraints: 'NOT NULL',
  );
  late final GeneratedColumn<DateTime> lastUsed = GeneratedColumn<DateTime>(
    'last_used',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: true,
    $customConstraints: 'NOT NULL',
  );
  @override
  List<GeneratedColumn> get $columns => [trigger, frequency, lastUsed];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'bang_frequency';
  @override
  Set<GeneratedColumn> get $primaryKey => {trigger};
  @override
  BangFrequencyData map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return BangFrequencyData(
      trigger:
          attachedDatabase.typeMapping.read(
            DriftSqlType.string,
            data['${effectivePrefix}trigger'],
          )!,
      frequency:
          attachedDatabase.typeMapping.read(
            DriftSqlType.int,
            data['${effectivePrefix}frequency'],
          )!,
      lastUsed:
          attachedDatabase.typeMapping.read(
            DriftSqlType.dateTime,
            data['${effectivePrefix}last_used'],
          )!,
    );
  }

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

  @override
  bool get dontWriteConstraints => true;
}

class BangFrequencyData extends DataClass
    implements Insertable<BangFrequencyData> {
  final String trigger;
  final int frequency;
  final DateTime lastUsed;
  const BangFrequencyData({
    required this.trigger,
    required this.frequency,
    required this.lastUsed,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['trigger'] = Variable<String>(trigger);
    map['frequency'] = Variable<int>(frequency);
    map['last_used'] = Variable<DateTime>(lastUsed);
    return map;
  }

  factory BangFrequencyData.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return BangFrequencyData(
      trigger: serializer.fromJson<String>(json['trigger']),
      frequency: serializer.fromJson<int>(json['frequency']),
      lastUsed: serializer.fromJson<DateTime>(json['last_used']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'trigger': serializer.toJson<String>(trigger),
      'frequency': serializer.toJson<int>(frequency),
      'last_used': serializer.toJson<DateTime>(lastUsed),
    };
  }

  BangFrequencyData copyWith({
    String? trigger,
    int? frequency,
    DateTime? lastUsed,
  }) => BangFrequencyData(
    trigger: trigger ?? this.trigger,
    frequency: frequency ?? this.frequency,
    lastUsed: lastUsed ?? this.lastUsed,
  );
  BangFrequencyData copyWithCompanion(BangFrequencyCompanion data) {
    return BangFrequencyData(
      trigger: data.trigger.present ? data.trigger.value : this.trigger,
      frequency: data.frequency.present ? data.frequency.value : this.frequency,
      lastUsed: data.lastUsed.present ? data.lastUsed.value : this.lastUsed,
    );
  }

  @override
  String toString() {
    return (StringBuffer('BangFrequencyData(')
          ..write('trigger: $trigger, ')
          ..write('frequency: $frequency, ')
          ..write('lastUsed: $lastUsed')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(trigger, frequency, lastUsed);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is BangFrequencyData &&
          other.trigger == this.trigger &&
          other.frequency == this.frequency &&
          other.lastUsed == this.lastUsed);
}

class BangFrequencyCompanion extends UpdateCompanion<BangFrequencyData> {
  final Value<String> trigger;
  final Value<int> frequency;
  final Value<DateTime> lastUsed;
  final Value<int> rowid;
  const BangFrequencyCompanion({
    this.trigger = const Value.absent(),
    this.frequency = const Value.absent(),
    this.lastUsed = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  BangFrequencyCompanion.insert({
    required String trigger,
    required int frequency,
    required DateTime lastUsed,
    this.rowid = const Value.absent(),
  }) : trigger = Value(trigger),
       frequency = Value(frequency),
       lastUsed = Value(lastUsed);
  static Insertable<BangFrequencyData> custom({
    Expression<String>? trigger,
    Expression<int>? frequency,
    Expression<DateTime>? lastUsed,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (trigger != null) 'trigger': trigger,
      if (frequency != null) 'frequency': frequency,
      if (lastUsed != null) 'last_used': lastUsed,
      if (rowid != null) 'rowid': rowid,
    });
  }

  BangFrequencyCompanion copyWith({
    Value<String>? trigger,
    Value<int>? frequency,
    Value<DateTime>? lastUsed,
    Value<int>? rowid,
  }) {
    return BangFrequencyCompanion(
      trigger: trigger ?? this.trigger,
      frequency: frequency ?? this.frequency,
      lastUsed: lastUsed ?? this.lastUsed,
      rowid: rowid ?? this.rowid,
    );
  }

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

  @override
  String toString() {
    return (StringBuffer('BangFrequencyCompanion(')
          ..write('trigger: $trigger, ')
          ..write('frequency: $frequency, ')
          ..write('lastUsed: $lastUsed, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class BangHistory extends Table with TableInfo<BangHistory, BangHistoryData> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  BangHistory(this.attachedDatabase, [this._alias]);
  late final GeneratedColumn<String> searchQuery = GeneratedColumn<String>(
    'search_query',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    $customConstraints: 'UNIQUE NOT NULL',
  );
  late final GeneratedColumn<String> trigger = GeneratedColumn<String>(
    'trigger',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    $customConstraints: 'NOT NULL REFERENCES bang("trigger")',
  );
  late final GeneratedColumn<DateTime> searchDate = GeneratedColumn<DateTime>(
    'search_date',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: true,
    $customConstraints: 'NOT NULL',
  );
  @override
  List<GeneratedColumn> get $columns => [searchQuery, trigger, searchDate];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'bang_history';
  @override
  Set<GeneratedColumn> get $primaryKey => const {};
  @override
  BangHistoryData map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return BangHistoryData(
      searchQuery:
          attachedDatabase.typeMapping.read(
            DriftSqlType.string,
            data['${effectivePrefix}search_query'],
          )!,
      trigger:
          attachedDatabase.typeMapping.read(
            DriftSqlType.string,
            data['${effectivePrefix}trigger'],
          )!,
      searchDate:
          attachedDatabase.typeMapping.read(
            DriftSqlType.dateTime,
            data['${effectivePrefix}search_date'],
          )!,
    );
  }

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

  @override
  bool get dontWriteConstraints => true;
}

class BangHistoryData extends DataClass implements Insertable<BangHistoryData> {
  final String searchQuery;
  final String trigger;
  final DateTime searchDate;
  const BangHistoryData({
    required this.searchQuery,
    required this.trigger,
    required this.searchDate,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['search_query'] = Variable<String>(searchQuery);
    map['trigger'] = Variable<String>(trigger);
    map['search_date'] = Variable<DateTime>(searchDate);
    return map;
  }

  factory BangHistoryData.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return BangHistoryData(
      searchQuery: serializer.fromJson<String>(json['search_query']),
      trigger: serializer.fromJson<String>(json['trigger']),
      searchDate: serializer.fromJson<DateTime>(json['search_date']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'search_query': serializer.toJson<String>(searchQuery),
      'trigger': serializer.toJson<String>(trigger),
      'search_date': serializer.toJson<DateTime>(searchDate),
    };
  }

  BangHistoryData copyWith({
    String? searchQuery,
    String? trigger,
    DateTime? searchDate,
  }) => BangHistoryData(
    searchQuery: searchQuery ?? this.searchQuery,
    trigger: trigger ?? this.trigger,
    searchDate: searchDate ?? this.searchDate,
  );
  BangHistoryData copyWithCompanion(BangHistoryCompanion data) {
    return BangHistoryData(
      searchQuery:
          data.searchQuery.present ? data.searchQuery.value : this.searchQuery,
      trigger: data.trigger.present ? data.trigger.value : this.trigger,
      searchDate:
          data.searchDate.present ? data.searchDate.value : this.searchDate,
    );
  }

  @override
  String toString() {
    return (StringBuffer('BangHistoryData(')
          ..write('searchQuery: $searchQuery, ')
          ..write('trigger: $trigger, ')
          ..write('searchDate: $searchDate')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(searchQuery, trigger, searchDate);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is BangHistoryData &&
          other.searchQuery == this.searchQuery &&
          other.trigger == this.trigger &&
          other.searchDate == this.searchDate);
}

class BangHistoryCompanion extends UpdateCompanion<BangHistoryData> {
  final Value<String> searchQuery;
  final Value<String> trigger;
  final Value<DateTime> searchDate;
  final Value<int> rowid;
  const BangHistoryCompanion({
    this.searchQuery = const Value.absent(),
    this.trigger = const Value.absent(),
    this.searchDate = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  BangHistoryCompanion.insert({
    required String searchQuery,
    required String trigger,
    required DateTime searchDate,
    this.rowid = const Value.absent(),
  }) : searchQuery = Value(searchQuery),
       trigger = Value(trigger),
       searchDate = Value(searchDate);
  static Insertable<BangHistoryData> custom({
    Expression<String>? searchQuery,
    Expression<String>? trigger,
    Expression<DateTime>? searchDate,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (searchQuery != null) 'search_query': searchQuery,
      if (trigger != null) 'trigger': trigger,
      if (searchDate != null) 'search_date': searchDate,
      if (rowid != null) 'rowid': rowid,
    });
  }

  BangHistoryCompanion copyWith({
    Value<String>? searchQuery,
    Value<String>? trigger,
    Value<DateTime>? searchDate,
    Value<int>? rowid,
  }) {
    return BangHistoryCompanion(
      searchQuery: searchQuery ?? this.searchQuery,
      trigger: trigger ?? this.trigger,
      searchDate: searchDate ?? this.searchDate,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (searchQuery.present) {
      map['search_query'] = Variable<String>(searchQuery.value);
    }
    if (trigger.present) {
      map['trigger'] = Variable<String>(trigger.value);
    }
    if (searchDate.present) {
      map['search_date'] = Variable<DateTime>(searchDate.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('BangHistoryCompanion(')
          ..write('searchQuery: $searchQuery, ')
          ..write('trigger: $trigger, ')
          ..write('searchDate: $searchDate, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class BangFts extends Table
    with TableInfo<BangFts, BangFt>, VirtualTableInfo<BangFts, BangFt> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  BangFts(this.attachedDatabase, [this._alias]);
  late final GeneratedColumn<String> trigger = GeneratedColumn<String>(
    'trigger',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    $customConstraints: '',
  );
  late final GeneratedColumn<String> websiteName = GeneratedColumn<String>(
    'website_name',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    $customConstraints: '',
  );
  @override
  List<GeneratedColumn> get $columns => [trigger, websiteName];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'bang_fts';
  @override
  Set<GeneratedColumn> get $primaryKey => const {};
  @override
  BangFt map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return BangFt(
      trigger:
          attachedDatabase.typeMapping.read(
            DriftSqlType.string,
            data['${effectivePrefix}trigger'],
          )!,
      websiteName:
          attachedDatabase.typeMapping.read(
            DriftSqlType.string,
            data['${effectivePrefix}website_name'],
          )!,
    );
  }

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

  @override
  bool get dontWriteConstraints => true;
  @override
  String get moduleAndArgs =>
      'fts5(trigger, website_name, content=bang, prefix=\'2 3\')';
}

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

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

  BangFt copyWith({String? trigger, String? websiteName}) => BangFt(
    trigger: trigger ?? this.trigger,
    websiteName: websiteName ?? this.websiteName,
  );
  BangFt copyWithCompanion(BangFtsCompanion data) {
    return BangFt(
      trigger: data.trigger.present ? data.trigger.value : this.trigger,
      websiteName:
          data.websiteName.present ? data.websiteName.value : this.websiteName,
    );
  }

  @override
  String toString() {
    return (StringBuffer('BangFt(')
          ..write('trigger: $trigger, ')
          ..write('websiteName: $websiteName')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(trigger, websiteName);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is BangFt &&
          other.trigger == this.trigger &&
          other.websiteName == this.websiteName);
}

class BangFtsCompanion extends UpdateCompanion<BangFt> {
  final Value<String> trigger;
  final Value<String> websiteName;
  final Value<int> rowid;
  const BangFtsCompanion({
    this.trigger = const Value.absent(),
    this.websiteName = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  BangFtsCompanion.insert({
    required String trigger,
    required String websiteName,
    this.rowid = const Value.absent(),
  }) : trigger = Value(trigger),
       websiteName = Value(websiteName);
  static Insertable<BangFt> custom({
    Expression<String>? trigger,
    Expression<String>? websiteName,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (trigger != null) 'trigger': trigger,
      if (websiteName != null) 'website_name': websiteName,
      if (rowid != null) 'rowid': rowid,
    });
  }

  BangFtsCompanion copyWith({
    Value<String>? trigger,
    Value<String>? websiteName,
    Value<int>? rowid,
  }) {
    return BangFtsCompanion(
      trigger: trigger ?? this.trigger,
      websiteName: websiteName ?? this.websiteName,
      rowid: rowid ?? this.rowid,
    );
  }

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

  @override
  String toString() {
    return (StringBuffer('BangFtsCompanion(')
          ..write('trigger: $trigger, ')
          ..write('websiteName: $websiteName, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class BangDataView extends ViewInfo<BangDataView, BangData>
    implements HasResultSet {
  final String? _alias;
  @override
  final _$BangDatabase attachedDatabase;
  BangDataView(this.attachedDatabase, [this._alias]);
  @override
  List<GeneratedColumn> get $columns => [
    trigger,
    group,
    websiteName,
    domain,
    urlTemplate,
    category,
    subCategory,
    format,
    frequency,
    lastUsed,
  ];
  @override
  String get aliasedName => _alias ?? entityName;
  @override
  String get entityName => 'bang_data_view';
  @override
  Map<SqlDialect, String> get createViewStatements => {
    SqlDialect.sqlite:
        'CREATE VIEW bang_data_view AS SELECT b.*, bf.frequency, bf.last_used FROM bang AS b LEFT JOIN bang_frequency AS bf ON b."trigger" = bf."trigger"',
  };
  @override
  BangDataView get asDslTable => this;
  @override
  BangData map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return BangData(
      websiteName:
          attachedDatabase.typeMapping.read(
            DriftSqlType.string,
            data['${effectivePrefix}website_name'],
          )!,
      domain:
          attachedDatabase.typeMapping.read(
            DriftSqlType.string,
            data['${effectivePrefix}domain'],
          )!,
      trigger:
          attachedDatabase.typeMapping.read(
            DriftSqlType.string,
            data['${effectivePrefix}trigger'],
          )!,
      urlTemplate:
          attachedDatabase.typeMapping.read(
            DriftSqlType.string,
            data['${effectivePrefix}url_template'],
          )!,
      category: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}category'],
      ),
      subCategory: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}sub_category'],
      ),
      format: BangTable.$converterformat.fromSql(
        attachedDatabase.typeMapping.read(
          DriftSqlType.string,
          data['${effectivePrefix}format'],
        ),
      ),
      frequency: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}frequency'],
      ),
      lastUsed: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}last_used'],
      ),
    );
  }

  late final GeneratedColumn<String> trigger = GeneratedColumn<String>(
    'trigger',
    aliasedName,
    false,
    type: DriftSqlType.string,
  );
  late final GeneratedColumnWithTypeConverter<BangGroup, int> group =
      GeneratedColumn<int>(
        'group',
        aliasedName,
        false,
        type: DriftSqlType.int,
      ).withConverter<BangGroup>(BangTable.$convertergroup);
  late final GeneratedColumn<String> websiteName = GeneratedColumn<String>(
    'website_name',
    aliasedName,
    false,
    type: DriftSqlType.string,
  );
  late final GeneratedColumn<String> domain = GeneratedColumn<String>(
    'domain',
    aliasedName,
    false,
    type: DriftSqlType.string,
  );
  late final GeneratedColumn<String> urlTemplate = GeneratedColumn<String>(
    'url_template',
    aliasedName,
    false,
    type: DriftSqlType.string,
  );
  late final GeneratedColumn<String> category = GeneratedColumn<String>(
    'category',
    aliasedName,
    true,
    type: DriftSqlType.string,
  );
  late final GeneratedColumn<String> subCategory = GeneratedColumn<String>(
    'sub_category',
    aliasedName,
    true,
    type: DriftSqlType.string,
  );
  late final GeneratedColumnWithTypeConverter<Set<BangFormat>?, String> format =
      GeneratedColumn<String>(
        'format',
        aliasedName,
        true,
        type: DriftSqlType.string,
      ).withConverter<Set<BangFormat>?>(BangTable.$converterformat);
  late final GeneratedColumn<int> frequency = GeneratedColumn<int>(
    'frequency',
    aliasedName,
    true,
    type: DriftSqlType.int,
  );
  late final GeneratedColumn<DateTime> lastUsed = GeneratedColumn<DateTime>(
    'last_used',
    aliasedName,
    true,
    type: DriftSqlType.dateTime,
  );
  @override
  BangDataView createAlias(String alias) {
    return BangDataView(attachedDatabase, alias);
  }

  @override
  Query? get query => null;
  @override
  Set<String> get readTables => const {'bang', 'bang_frequency'};
}

abstract class _$BangDatabase extends GeneratedDatabase {
  _$BangDatabase(QueryExecutor e) : super(e);
  $BangDatabaseManager get managers => $BangDatabaseManager(this);
  late final BangTable bang = BangTable(this);
  late final BangSync bangSync = BangSync(this);
  late final BangFrequency bangFrequency = BangFrequency(this);
  late final BangHistory bangHistory = BangHistory(this);
  late final BangFts bangFts = BangFts(this);
  late final BangDataView bangDataView = BangDataView(this);
  late final Trigger bangAfterInsert = Trigger(
    'CREATE TRIGGER bang_after_insert AFTER INSERT ON bang BEGIN INSERT INTO bang_fts ("rowid", "trigger", website_name) VALUES (new."rowid", new."trigger", new.website_name);END',
    'bang_after_insert',
  );
  late final Trigger bangAfterDelete = Trigger(
    'CREATE TRIGGER bang_after_delete AFTER DELETE ON bang BEGIN INSERT INTO bang_fts (bang_fts, "rowid", "trigger", website_name) VALUES (\'delete\', old."rowid", old."trigger", old.website_name);END',
    'bang_after_delete',
  );
  late final Trigger bangAfterUpdate = Trigger(
    'CREATE TRIGGER bang_after_update AFTER UPDATE ON bang BEGIN INSERT INTO bang_fts (bang_fts, "rowid", "trigger", website_name) VALUES (\'delete\', old."rowid", old."trigger", old.website_name);INSERT INTO bang_fts ("rowid", "trigger", website_name) VALUES (new."rowid", new."trigger", new.website_name);END',
    'bang_after_update',
  );
  late final BangDao bangDao = BangDao(this as BangDatabase);
  late final SyncDao syncDao = SyncDao(this as BangDatabase);
  Future<int> optimizeFtsIndex() {
    return customInsert(
      'INSERT INTO bang_fts (bang_fts) VALUES (\'optimize\')',
      variables: [],
      updates: {bangFts},
    );
  }

  Selectable<BangData> queryBangs({required String query}) {
    return customSelect(
      'WITH weights AS (SELECT 10.0 AS "trigger", 5.0 AS website_name) SELECT b.*, bf.frequency, bf.last_used, bm25(bang_fts, weights."trigger", weights.website_name) AS weighted_rank FROM bang_fts(?1)AS fts INNER JOIN bang AS b ON b."rowid" = fts."rowid" LEFT JOIN bang_frequency AS bf ON b."trigger" = bf."trigger" CROSS JOIN weights ORDER BY weighted_rank ASC, bf.frequency NULLS LAST',
      variables: [Variable<String>(query)],
      readsFrom: {bangFrequency, bangFts, bang},
    ).map(
      (QueryRow row) => BangData(
        websiteName: row.read<String>('website_name'),
        domain: row.read<String>('domain'),
        trigger: row.read<String>('trigger'),
        urlTemplate: row.read<String>('url_template'),
        category: row.readNullable<String>('category'),
        subCategory: row.readNullable<String>('sub_category'),
        format: BangTable.$converterformat.fromSql(
          row.readNullable<String>('format'),
        ),
        frequency: row.readNullable<int>('frequency'),
        lastUsed: row.readNullable<DateTime>('last_used'),
      ),
    );
  }

  Selectable<BangData> queryBangsBasic({required String query}) {
    return customSelect(
      'WITH weights AS (SELECT 10.0 AS "trigger", 5.0 AS website_name) SELECT b.*, bf.frequency, bf.last_used, bm25(bang_fts, weights."trigger", weights.website_name) AS weighted_rank FROM bang_fts AS fts INNER JOIN bang AS b ON b."rowid" = fts."rowid" LEFT JOIN bang_frequency AS bf ON b."trigger" = bf."trigger" CROSS JOIN weights WHERE fts."trigger" LIKE ?1 OR fts.website_name LIKE ?1 ORDER BY weighted_rank ASC, bf.frequency NULLS LAST',
      variables: [Variable<String>(query)],
      readsFrom: {bangFrequency, bangFts, bang},
    ).map(
      (QueryRow row) => BangData(
        websiteName: row.read<String>('website_name'),
        domain: row.read<String>('domain'),
        trigger: row.read<String>('trigger'),
        urlTemplate: row.read<String>('url_template'),
        category: row.readNullable<String>('category'),
        subCategory: row.readNullable<String>('sub_category'),
        format: BangTable.$converterformat.fromSql(
          row.readNullable<String>('format'),
        ),
        frequency: row.readNullable<int>('frequency'),
        lastUsed: row.readNullable<DateTime>('last_used'),
      ),
    );
  }

  Selectable<String> categoriesJson() {
    return customSelect(
      'WITH categories AS (SELECT b.category, json_group_array(DISTINCT b.sub_category ORDER BY b.sub_category)AS sub_categories FROM bang AS b WHERE b.category IS NOT NULL AND b.sub_category IS NOT NULL GROUP BY b.category ORDER BY b.category) SELECT json_group_object(c.category, json(c.sub_categories)) AS categories_json FROM categories AS c',
      variables: [],
      readsFrom: {bang},
    ).map((QueryRow row) => row.read<String>('categories_json'));
  }

  Selectable<SearchHistoryEntry> searchHistoryEntries({required int limit}) {
    return customSelect(
      'SELECT * FROM bang_history ORDER BY search_date DESC LIMIT ?1',
      variables: [Variable<int>(limit)],
      readsFrom: {bangHistory},
    ).map(
      (QueryRow row) => SearchHistoryEntry(
        searchQuery: row.read<String>('search_query'),
        trigger: row.read<String>('trigger'),
        searchDate: row.read<DateTime>('search_date'),
      ),
    );
  }

  Future<int> evictHistoryEntries({required int limit}) {
    return customUpdate(
      'DELETE FROM bang_history WHERE "rowid" IN (SELECT "rowid" FROM bang_history ORDER BY search_date DESC LIMIT -1 OFFSET ?1)',
      variables: [Variable<int>(limit)],
      updates: {bangHistory},
      updateKind: UpdateKind.delete,
    );
  }

  @override
  Iterable<TableInfo<Table, Object?>> get allTables =>
      allSchemaEntities.whereType<TableInfo<Table, Object?>>();
  @override
  List<DatabaseSchemaEntity> get allSchemaEntities => [
    bang,
    bangSync,
    bangFrequency,
    bangHistory,
    bangFts,
    bangDataView,
    bangAfterInsert,
    bangAfterDelete,
    bangAfterUpdate,
  ];
  @override
  StreamQueryUpdateRules get streamUpdateRules => const StreamQueryUpdateRules([
    WritePropagation(
      on: TableUpdateQuery.onTableName(
        'bang',
        limitUpdateKind: UpdateKind.delete,
      ),
      result: [TableUpdate('bang_frequency', kind: UpdateKind.delete)],
    ),
    WritePropagation(
      on: TableUpdateQuery.onTableName(
        'bang',
        limitUpdateKind: UpdateKind.insert,
      ),
      result: [TableUpdate('bang_fts', kind: UpdateKind.insert)],
    ),
    WritePropagation(
      on: TableUpdateQuery.onTableName(
        'bang',
        limitUpdateKind: UpdateKind.delete,
      ),
      result: [TableUpdate('bang_fts', kind: UpdateKind.insert)],
    ),
    WritePropagation(
      on: TableUpdateQuery.onTableName(
        'bang',
        limitUpdateKind: UpdateKind.update,
      ),
      result: [TableUpdate('bang_fts', kind: UpdateKind.insert)],
    ),
  ]);
}

typedef $BangTableCreateCompanionBuilder =
    BangCompanion Function({
      required String trigger,
      required BangGroup group,
      required String websiteName,
      required String domain,
      required String urlTemplate,
      Value<String?> category,
      Value<String?> subCategory,
      Value<Set<BangFormat>?> format,
      Value<int> rowid,
    });
typedef $BangTableUpdateCompanionBuilder =
    BangCompanion Function({
      Value<String> trigger,
      Value<BangGroup> group,
      Value<String> websiteName,
      Value<String> domain,
      Value<String> urlTemplate,
      Value<String?> category,
      Value<String?> subCategory,
      Value<Set<BangFormat>?> format,
      Value<int> rowid,
    });

final class $BangTableReferences
    extends BaseReferences<_$BangDatabase, BangTable, Bang> {
  $BangTableReferences(super.$_db, super.$_table, super.$_typedResult);

  static MultiTypedResultKey<BangFrequency, List<BangFrequencyData>>
  _bangFrequencyRefsTable(_$BangDatabase db) => MultiTypedResultKey.fromTable(
    db.bangFrequency,
    aliasName: $_aliasNameGenerator(db.bang.trigger, db.bangFrequency.trigger),
  );

  $BangFrequencyProcessedTableManager get bangFrequencyRefs {
    final manager = $BangFrequencyTableManager($_db, $_db.bangFrequency).filter(
      (f) => f.trigger.trigger.sqlEquals($_itemColumn<String>('trigger')!),
    );

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

  static MultiTypedResultKey<BangHistory, List<BangHistoryData>>
  _bangHistoryRefsTable(_$BangDatabase db) => MultiTypedResultKey.fromTable(
    db.bangHistory,
    aliasName: $_aliasNameGenerator(db.bang.trigger, db.bangHistory.trigger),
  );

  $BangHistoryProcessedTableManager get bangHistoryRefs {
    final manager = $BangHistoryTableManager($_db, $_db.bangHistory).filter(
      (f) => f.trigger.trigger.sqlEquals($_itemColumn<String>('trigger')!),
    );

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

class $BangTableFilterComposer extends Composer<_$BangDatabase, BangTable> {
  $BangTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get trigger => $composableBuilder(
    column: $table.trigger,
    builder: (column) => ColumnFilters(column),
  );

  ColumnWithTypeConverterFilters<BangGroup, BangGroup, int> get group =>
      $composableBuilder(
        column: $table.group,
        builder: (column) => ColumnWithTypeConverterFilters(column),
      );

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

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

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

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

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

  ColumnWithTypeConverterFilters<Set<BangFormat>?, Set<BangFormat>, String>
  get format => $composableBuilder(
    column: $table.format,
    builder: (column) => ColumnWithTypeConverterFilters(column),
  );

  Expression<bool> bangFrequencyRefs(
    Expression<bool> Function($BangFrequencyFilterComposer f) f,
  ) {
    final $BangFrequencyFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.trigger,
      referencedTable: $db.bangFrequency,
      getReferencedColumn: (t) => t.trigger,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $BangFrequencyFilterComposer(
            $db: $db,
            $table: $db.bangFrequency,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }

  Expression<bool> bangHistoryRefs(
    Expression<bool> Function($BangHistoryFilterComposer f) f,
  ) {
    final $BangHistoryFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.trigger,
      referencedTable: $db.bangHistory,
      getReferencedColumn: (t) => t.trigger,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $BangHistoryFilterComposer(
            $db: $db,
            $table: $db.bangHistory,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $BangTableOrderingComposer extends Composer<_$BangDatabase, BangTable> {
  $BangTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get trigger => $composableBuilder(
    column: $table.trigger,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

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

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

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

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

class $BangTableAnnotationComposer extends Composer<_$BangDatabase, BangTable> {
  $BangTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get trigger =>
      $composableBuilder(column: $table.trigger, builder: (column) => column);

  GeneratedColumnWithTypeConverter<BangGroup, int> get group =>
      $composableBuilder(column: $table.group, builder: (column) => column);

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

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

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

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

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

  GeneratedColumnWithTypeConverter<Set<BangFormat>?, String> get format =>
      $composableBuilder(column: $table.format, builder: (column) => column);

  Expression<T> bangFrequencyRefs<T extends Object>(
    Expression<T> Function($BangFrequencyAnnotationComposer a) f,
  ) {
    final $BangFrequencyAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.trigger,
      referencedTable: $db.bangFrequency,
      getReferencedColumn: (t) => t.trigger,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $BangFrequencyAnnotationComposer(
            $db: $db,
            $table: $db.bangFrequency,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }

  Expression<T> bangHistoryRefs<T extends Object>(
    Expression<T> Function($BangHistoryAnnotationComposer a) f,
  ) {
    final $BangHistoryAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.trigger,
      referencedTable: $db.bangHistory,
      getReferencedColumn: (t) => t.trigger,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $BangHistoryAnnotationComposer(
            $db: $db,
            $table: $db.bangHistory,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $BangTableTableManager
    extends
        RootTableManager<
          _$BangDatabase,
          BangTable,
          Bang,
          $BangTableFilterComposer,
          $BangTableOrderingComposer,
          $BangTableAnnotationComposer,
          $BangTableCreateCompanionBuilder,
          $BangTableUpdateCompanionBuilder,
          (Bang, $BangTableReferences),
          Bang,
          PrefetchHooks Function({bool bangFrequencyRefs, bool bangHistoryRefs})
        > {
  $BangTableTableManager(_$BangDatabase db, BangTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer:
              () => $BangTableFilterComposer($db: db, $table: table),
          createOrderingComposer:
              () => $BangTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer:
              () => $BangTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> trigger = const Value.absent(),
                Value<BangGroup> group = const Value.absent(),
                Value<String> websiteName = const Value.absent(),
                Value<String> domain = const Value.absent(),
                Value<String> urlTemplate = const Value.absent(),
                Value<String?> category = const Value.absent(),
                Value<String?> subCategory = const Value.absent(),
                Value<Set<BangFormat>?> format = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => BangCompanion(
                trigger: trigger,
                group: group,
                websiteName: websiteName,
                domain: domain,
                urlTemplate: urlTemplate,
                category: category,
                subCategory: subCategory,
                format: format,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String trigger,
                required BangGroup group,
                required String websiteName,
                required String domain,
                required String urlTemplate,
                Value<String?> category = const Value.absent(),
                Value<String?> subCategory = const Value.absent(),
                Value<Set<BangFormat>?> format = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => BangCompanion.insert(
                trigger: trigger,
                group: group,
                websiteName: websiteName,
                domain: domain,
                urlTemplate: urlTemplate,
                category: category,
                subCategory: subCategory,
                format: format,
                rowid: rowid,
              ),
          withReferenceMapper:
              (p0) =>
                  p0
                      .map(
                        (e) => (
                          e.readTable(table),
                          $BangTableReferences(db, table, e),
                        ),
                      )
                      .toList(),
          prefetchHooksCallback: ({
            bangFrequencyRefs = false,
            bangHistoryRefs = false,
          }) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [
                if (bangFrequencyRefs) db.bangFrequency,
                if (bangHistoryRefs) db.bangHistory,
              ],
              addJoins: null,
              getPrefetchedDataCallback: (items) async {
                return [
                  if (bangFrequencyRefs)
                    await $_getPrefetchedData<
                      Bang,
                      BangTable,
                      BangFrequencyData
                    >(
                      currentTable: table,
                      referencedTable: $BangTableReferences
                          ._bangFrequencyRefsTable(db),
                      managerFromTypedResult:
                          (p0) =>
                              $BangTableReferences(
                                db,
                                table,
                                p0,
                              ).bangFrequencyRefs,
                      referencedItemsForCurrentItem:
                          (item, referencedItems) => referencedItems.where(
                            (e) => e.trigger == item.trigger,
                          ),
                      typedResults: items,
                    ),
                  if (bangHistoryRefs)
                    await $_getPrefetchedData<Bang, BangTable, BangHistoryData>(
                      currentTable: table,
                      referencedTable: $BangTableReferences
                          ._bangHistoryRefsTable(db),
                      managerFromTypedResult:
                          (p0) =>
                              $BangTableReferences(
                                db,
                                table,
                                p0,
                              ).bangHistoryRefs,
                      referencedItemsForCurrentItem:
                          (item, referencedItems) => referencedItems.where(
                            (e) => e.trigger == item.trigger,
                          ),
                      typedResults: items,
                    ),
                ];
              },
            );
          },
        ),
      );
}

typedef $BangTableProcessedTableManager =
    ProcessedTableManager<
      _$BangDatabase,
      BangTable,
      Bang,
      $BangTableFilterComposer,
      $BangTableOrderingComposer,
      $BangTableAnnotationComposer,
      $BangTableCreateCompanionBuilder,
      $BangTableUpdateCompanionBuilder,
      (Bang, $BangTableReferences),
      Bang,
      PrefetchHooks Function({bool bangFrequencyRefs, bool bangHistoryRefs})
    >;
typedef $BangSyncCreateCompanionBuilder =
    BangSyncCompanion Function({
      Value<BangGroup> group,
      required DateTime lastSync,
    });
typedef $BangSyncUpdateCompanionBuilder =
    BangSyncCompanion Function({
      Value<BangGroup> group,
      Value<DateTime> lastSync,
    });

class $BangSyncFilterComposer extends Composer<_$BangDatabase, BangSync> {
  $BangSyncFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnWithTypeConverterFilters<BangGroup, BangGroup, int> get group =>
      $composableBuilder(
        column: $table.group,
        builder: (column) => ColumnWithTypeConverterFilters(column),
      );

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

class $BangSyncOrderingComposer extends Composer<_$BangDatabase, BangSync> {
  $BangSyncOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<int> get group => $composableBuilder(
    column: $table.group,
    builder: (column) => ColumnOrderings(column),
  );

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

class $BangSyncAnnotationComposer extends Composer<_$BangDatabase, BangSync> {
  $BangSyncAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumnWithTypeConverter<BangGroup, int> get group =>
      $composableBuilder(column: $table.group, builder: (column) => column);

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

class $BangSyncTableManager
    extends
        RootTableManager<
          _$BangDatabase,
          BangSync,
          BangSyncData,
          $BangSyncFilterComposer,
          $BangSyncOrderingComposer,
          $BangSyncAnnotationComposer,
          $BangSyncCreateCompanionBuilder,
          $BangSyncUpdateCompanionBuilder,
          (
            BangSyncData,
            BaseReferences<_$BangDatabase, BangSync, BangSyncData>,
          ),
          BangSyncData,
          PrefetchHooks Function()
        > {
  $BangSyncTableManager(_$BangDatabase db, BangSync table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer:
              () => $BangSyncFilterComposer($db: db, $table: table),
          createOrderingComposer:
              () => $BangSyncOrderingComposer($db: db, $table: table),
          createComputedFieldComposer:
              () => $BangSyncAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<BangGroup> group = const Value.absent(),
                Value<DateTime> lastSync = const Value.absent(),
              }) => BangSyncCompanion(group: group, lastSync: lastSync),
          createCompanionCallback:
              ({
                Value<BangGroup> group = const Value.absent(),
                required DateTime lastSync,
              }) => BangSyncCompanion.insert(group: group, lastSync: lastSync),
          withReferenceMapper:
              (p0) =>
                  p0
                      .map(
                        (e) => (
                          e.readTable(table),
                          BaseReferences(db, table, e),
                        ),
                      )
                      .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $BangSyncProcessedTableManager =
    ProcessedTableManager<
      _$BangDatabase,
      BangSync,
      BangSyncData,
      $BangSyncFilterComposer,
      $BangSyncOrderingComposer,
      $BangSyncAnnotationComposer,
      $BangSyncCreateCompanionBuilder,
      $BangSyncUpdateCompanionBuilder,
      (BangSyncData, BaseReferences<_$BangDatabase, BangSync, BangSyncData>),
      BangSyncData,
      PrefetchHooks Function()
    >;
typedef $BangFrequencyCreateCompanionBuilder =
    BangFrequencyCompanion Function({
      required String trigger,
      required int frequency,
      required DateTime lastUsed,
      Value<int> rowid,
    });
typedef $BangFrequencyUpdateCompanionBuilder =
    BangFrequencyCompanion Function({
      Value<String> trigger,
      Value<int> frequency,
      Value<DateTime> lastUsed,
      Value<int> rowid,
    });

final class $BangFrequencyReferences
    extends BaseReferences<_$BangDatabase, BangFrequency, BangFrequencyData> {
  $BangFrequencyReferences(super.$_db, super.$_table, super.$_typedResult);

  static BangTable _triggerTable(_$BangDatabase db) => db.bang.createAlias(
    $_aliasNameGenerator(db.bangFrequency.trigger, db.bang.trigger),
  );

  $BangTableProcessedTableManager get trigger {
    final $_column = $_itemColumn<String>('trigger')!;

    final manager = $BangTableTableManager(
      $_db,
      $_db.bang,
    ).filter((f) => f.trigger.sqlEquals($_column));
    final item = $_typedResult.readTableOrNull(_triggerTable($_db));
    if (item == null) return manager;
    return ProcessedTableManager(
      manager.$state.copyWith(prefetchedData: [item]),
    );
  }
}

class $BangFrequencyFilterComposer
    extends Composer<_$BangDatabase, BangFrequency> {
  $BangFrequencyFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<int> get frequency => $composableBuilder(
    column: $table.frequency,
    builder: (column) => ColumnFilters(column),
  );

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

  $BangTableFilterComposer get trigger {
    final $BangTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.trigger,
      referencedTable: $db.bang,
      getReferencedColumn: (t) => t.trigger,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $BangTableFilterComposer(
            $db: $db,
            $table: $db.bang,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }
}

class $BangFrequencyOrderingComposer
    extends Composer<_$BangDatabase, BangFrequency> {
  $BangFrequencyOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<int> get frequency => $composableBuilder(
    column: $table.frequency,
    builder: (column) => ColumnOrderings(column),
  );

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

  $BangTableOrderingComposer get trigger {
    final $BangTableOrderingComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.trigger,
      referencedTable: $db.bang,
      getReferencedColumn: (t) => t.trigger,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $BangTableOrderingComposer(
            $db: $db,
            $table: $db.bang,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }
}

class $BangFrequencyAnnotationComposer
    extends Composer<_$BangDatabase, BangFrequency> {
  $BangFrequencyAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<int> get frequency =>
      $composableBuilder(column: $table.frequency, builder: (column) => column);

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

  $BangTableAnnotationComposer get trigger {
    final $BangTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.trigger,
      referencedTable: $db.bang,
      getReferencedColumn: (t) => t.trigger,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $BangTableAnnotationComposer(
            $db: $db,
            $table: $db.bang,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }
}

class $BangFrequencyTableManager
    extends
        RootTableManager<
          _$BangDatabase,
          BangFrequency,
          BangFrequencyData,
          $BangFrequencyFilterComposer,
          $BangFrequencyOrderingComposer,
          $BangFrequencyAnnotationComposer,
          $BangFrequencyCreateCompanionBuilder,
          $BangFrequencyUpdateCompanionBuilder,
          (BangFrequencyData, $BangFrequencyReferences),
          BangFrequencyData,
          PrefetchHooks Function({bool trigger})
        > {
  $BangFrequencyTableManager(_$BangDatabase db, BangFrequency table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer:
              () => $BangFrequencyFilterComposer($db: db, $table: table),
          createOrderingComposer:
              () => $BangFrequencyOrderingComposer($db: db, $table: table),
          createComputedFieldComposer:
              () => $BangFrequencyAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> trigger = const Value.absent(),
                Value<int> frequency = const Value.absent(),
                Value<DateTime> lastUsed = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => BangFrequencyCompanion(
                trigger: trigger,
                frequency: frequency,
                lastUsed: lastUsed,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String trigger,
                required int frequency,
                required DateTime lastUsed,
                Value<int> rowid = const Value.absent(),
              }) => BangFrequencyCompanion.insert(
                trigger: trigger,
                frequency: frequency,
                lastUsed: lastUsed,
                rowid: rowid,
              ),
          withReferenceMapper:
              (p0) =>
                  p0
                      .map(
                        (e) => (
                          e.readTable(table),
                          $BangFrequencyReferences(db, table, e),
                        ),
                      )
                      .toList(),
          prefetchHooksCallback: ({trigger = false}) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [],
              addJoins: <
                T extends TableManagerState<
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic
                >
              >(state) {
                if (trigger) {
                  state =
                      state.withJoin(
                            currentTable: table,
                            currentColumn: table.trigger,
                            referencedTable: $BangFrequencyReferences
                                ._triggerTable(db),
                            referencedColumn:
                                $BangFrequencyReferences
                                    ._triggerTable(db)
                                    .trigger,
                          )
                          as T;
                }

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

typedef $BangFrequencyProcessedTableManager =
    ProcessedTableManager<
      _$BangDatabase,
      BangFrequency,
      BangFrequencyData,
      $BangFrequencyFilterComposer,
      $BangFrequencyOrderingComposer,
      $BangFrequencyAnnotationComposer,
      $BangFrequencyCreateCompanionBuilder,
      $BangFrequencyUpdateCompanionBuilder,
      (BangFrequencyData, $BangFrequencyReferences),
      BangFrequencyData,
      PrefetchHooks Function({bool trigger})
    >;
typedef $BangHistoryCreateCompanionBuilder =
    BangHistoryCompanion Function({
      required String searchQuery,
      required String trigger,
      required DateTime searchDate,
      Value<int> rowid,
    });
typedef $BangHistoryUpdateCompanionBuilder =
    BangHistoryCompanion Function({
      Value<String> searchQuery,
      Value<String> trigger,
      Value<DateTime> searchDate,
      Value<int> rowid,
    });

final class $BangHistoryReferences
    extends BaseReferences<_$BangDatabase, BangHistory, BangHistoryData> {
  $BangHistoryReferences(super.$_db, super.$_table, super.$_typedResult);

  static BangTable _triggerTable(_$BangDatabase db) => db.bang.createAlias(
    $_aliasNameGenerator(db.bangHistory.trigger, db.bang.trigger),
  );

  $BangTableProcessedTableManager get trigger {
    final $_column = $_itemColumn<String>('trigger')!;

    final manager = $BangTableTableManager(
      $_db,
      $_db.bang,
    ).filter((f) => f.trigger.sqlEquals($_column));
    final item = $_typedResult.readTableOrNull(_triggerTable($_db));
    if (item == null) return manager;
    return ProcessedTableManager(
      manager.$state.copyWith(prefetchedData: [item]),
    );
  }
}

class $BangHistoryFilterComposer extends Composer<_$BangDatabase, BangHistory> {
  $BangHistoryFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get searchQuery => $composableBuilder(
    column: $table.searchQuery,
    builder: (column) => ColumnFilters(column),
  );

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

  $BangTableFilterComposer get trigger {
    final $BangTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.trigger,
      referencedTable: $db.bang,
      getReferencedColumn: (t) => t.trigger,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $BangTableFilterComposer(
            $db: $db,
            $table: $db.bang,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }
}

class $BangHistoryOrderingComposer
    extends Composer<_$BangDatabase, BangHistory> {
  $BangHistoryOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get searchQuery => $composableBuilder(
    column: $table.searchQuery,
    builder: (column) => ColumnOrderings(column),
  );

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

  $BangTableOrderingComposer get trigger {
    final $BangTableOrderingComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.trigger,
      referencedTable: $db.bang,
      getReferencedColumn: (t) => t.trigger,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $BangTableOrderingComposer(
            $db: $db,
            $table: $db.bang,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }
}

class $BangHistoryAnnotationComposer
    extends Composer<_$BangDatabase, BangHistory> {
  $BangHistoryAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get searchQuery => $composableBuilder(
    column: $table.searchQuery,
    builder: (column) => column,
  );

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

  $BangTableAnnotationComposer get trigger {
    final $BangTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.trigger,
      referencedTable: $db.bang,
      getReferencedColumn: (t) => t.trigger,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $BangTableAnnotationComposer(
            $db: $db,
            $table: $db.bang,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }
}

class $BangHistoryTableManager
    extends
        RootTableManager<
          _$BangDatabase,
          BangHistory,
          BangHistoryData,
          $BangHistoryFilterComposer,
          $BangHistoryOrderingComposer,
          $BangHistoryAnnotationComposer,
          $BangHistoryCreateCompanionBuilder,
          $BangHistoryUpdateCompanionBuilder,
          (BangHistoryData, $BangHistoryReferences),
          BangHistoryData,
          PrefetchHooks Function({bool trigger})
        > {
  $BangHistoryTableManager(_$BangDatabase db, BangHistory table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer:
              () => $BangHistoryFilterComposer($db: db, $table: table),
          createOrderingComposer:
              () => $BangHistoryOrderingComposer($db: db, $table: table),
          createComputedFieldComposer:
              () => $BangHistoryAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> searchQuery = const Value.absent(),
                Value<String> trigger = const Value.absent(),
                Value<DateTime> searchDate = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => BangHistoryCompanion(
                searchQuery: searchQuery,
                trigger: trigger,
                searchDate: searchDate,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String searchQuery,
                required String trigger,
                required DateTime searchDate,
                Value<int> rowid = const Value.absent(),
              }) => BangHistoryCompanion.insert(
                searchQuery: searchQuery,
                trigger: trigger,
                searchDate: searchDate,
                rowid: rowid,
              ),
          withReferenceMapper:
              (p0) =>
                  p0
                      .map(
                        (e) => (
                          e.readTable(table),
                          $BangHistoryReferences(db, table, e),
                        ),
                      )
                      .toList(),
          prefetchHooksCallback: ({trigger = false}) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [],
              addJoins: <
                T extends TableManagerState<
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic,
                  dynamic
                >
              >(state) {
                if (trigger) {
                  state =
                      state.withJoin(
                            currentTable: table,
                            currentColumn: table.trigger,
                            referencedTable: $BangHistoryReferences
                                ._triggerTable(db),
                            referencedColumn:
                                $BangHistoryReferences
                                    ._triggerTable(db)
                                    .trigger,
                          )
                          as T;
                }

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

typedef $BangHistoryProcessedTableManager =
    ProcessedTableManager<
      _$BangDatabase,
      BangHistory,
      BangHistoryData,
      $BangHistoryFilterComposer,
      $BangHistoryOrderingComposer,
      $BangHistoryAnnotationComposer,
      $BangHistoryCreateCompanionBuilder,
      $BangHistoryUpdateCompanionBuilder,
      (BangHistoryData, $BangHistoryReferences),
      BangHistoryData,
      PrefetchHooks Function({bool trigger})
    >;
typedef $BangFtsCreateCompanionBuilder =
    BangFtsCompanion Function({
      required String trigger,
      required String websiteName,
      Value<int> rowid,
    });
typedef $BangFtsUpdateCompanionBuilder =
    BangFtsCompanion Function({
      Value<String> trigger,
      Value<String> websiteName,
      Value<int> rowid,
    });

class $BangFtsFilterComposer extends Composer<_$BangDatabase, BangFts> {
  $BangFtsFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get trigger => $composableBuilder(
    column: $table.trigger,
    builder: (column) => ColumnFilters(column),
  );

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

class $BangFtsOrderingComposer extends Composer<_$BangDatabase, BangFts> {
  $BangFtsOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get trigger => $composableBuilder(
    column: $table.trigger,
    builder: (column) => ColumnOrderings(column),
  );

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

class $BangFtsAnnotationComposer extends Composer<_$BangDatabase, BangFts> {
  $BangFtsAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get trigger =>
      $composableBuilder(column: $table.trigger, builder: (column) => column);

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

class $BangFtsTableManager
    extends
        RootTableManager<
          _$BangDatabase,
          BangFts,
          BangFt,
          $BangFtsFilterComposer,
          $BangFtsOrderingComposer,
          $BangFtsAnnotationComposer,
          $BangFtsCreateCompanionBuilder,
          $BangFtsUpdateCompanionBuilder,
          (BangFt, BaseReferences<_$BangDatabase, BangFts, BangFt>),
          BangFt,
          PrefetchHooks Function()
        > {
  $BangFtsTableManager(_$BangDatabase db, BangFts table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer:
              () => $BangFtsFilterComposer($db: db, $table: table),
          createOrderingComposer:
              () => $BangFtsOrderingComposer($db: db, $table: table),
          createComputedFieldComposer:
              () => $BangFtsAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> trigger = const Value.absent(),
                Value<String> websiteName = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => BangFtsCompanion(
                trigger: trigger,
                websiteName: websiteName,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String trigger,
                required String websiteName,
                Value<int> rowid = const Value.absent(),
              }) => BangFtsCompanion.insert(
                trigger: trigger,
                websiteName: websiteName,
                rowid: rowid,
              ),
          withReferenceMapper:
              (p0) =>
                  p0
                      .map(
                        (e) => (
                          e.readTable(table),
                          BaseReferences(db, table, e),
                        ),
                      )
                      .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $BangFtsProcessedTableManager =
    ProcessedTableManager<
      _$BangDatabase,
      BangFts,
      BangFt,
      $BangFtsFilterComposer,
      $BangFtsOrderingComposer,
      $BangFtsAnnotationComposer,
      $BangFtsCreateCompanionBuilder,
      $BangFtsUpdateCompanionBuilder,
      (BangFt, BaseReferences<_$BangDatabase, BangFts, BangFt>),
      BangFt,
      PrefetchHooks Function()
    >;

class $BangDatabaseManager {
  final _$BangDatabase _db;
  $BangDatabaseManager(this._db);
  $BangTableTableManager get bang => $BangTableTableManager(_db, _db.bang);
  $BangSyncTableManager get bangSync =>
      $BangSyncTableManager(_db, _db.bangSync);
  $BangFrequencyTableManager get bangFrequency =>
      $BangFrequencyTableManager(_db, _db.bangFrequency);
  $BangHistoryTableManager get bangHistory =>
      $BangHistoryTableManager(_db, _db.bangHistory);
  $BangFtsTableManager get bangFts => $BangFtsTableManager(_db, _db.bangFts);
}