// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'database.dart';

// ignore_for_file: type=lint
class Setting extends Table with TableInfo<Setting, SettingData> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  Setting(this.attachedDatabase, [this._alias]);
  late final GeneratedColumn<String> key = GeneratedColumn<String>(
    'key',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    $customConstraints: 'PRIMARY KEY NOT NULL',
  );
  late final GeneratedColumn<String> partitionKey = GeneratedColumn<String>(
    'partition_key',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    $customConstraints: '',
  );
  late final GeneratedColumn<DriftAny> value = GeneratedColumn<DriftAny>(
    'value',
    aliasedName,
    true,
    type: DriftSqlType.any,
    requiredDuringInsert: false,
    $customConstraints: '',
  );
  @override
  List<GeneratedColumn> get $columns => [key, partitionKey, value];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'setting';
  @override
  Set<GeneratedColumn> get $primaryKey => {key};
  @override
  SettingData map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return SettingData(
      key: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}key'],
      )!,
      partitionKey: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}partition_key'],
      ),
      value: attachedDatabase.typeMapping.read(
        DriftSqlType.any,
        data['${effectivePrefix}value'],
      ),
    );
  }

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

  @override
  bool get isStrict => true;
  @override
  bool get dontWriteConstraints => true;
}

class SettingData extends DataClass implements Insertable<SettingData> {
  final String key;
  final String? partitionKey;
  final DriftAny? value;
  const SettingData({required this.key, this.partitionKey, this.value});
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['key'] = Variable<String>(key);
    if (!nullToAbsent || partitionKey != null) {
      map['partition_key'] = Variable<String>(partitionKey);
    }
    if (!nullToAbsent || value != null) {
      map['value'] = Variable<DriftAny>(value);
    }
    return map;
  }

  factory SettingData.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return SettingData(
      key: serializer.fromJson<String>(json['key']),
      partitionKey: serializer.fromJson<String?>(json['partition_key']),
      value: serializer.fromJson<DriftAny?>(json['value']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'key': serializer.toJson<String>(key),
      'partition_key': serializer.toJson<String?>(partitionKey),
      'value': serializer.toJson<DriftAny?>(value),
    };
  }

  SettingData copyWith({
    String? key,
    Value<String?> partitionKey = const Value.absent(),
    Value<DriftAny?> value = const Value.absent(),
  }) => SettingData(
    key: key ?? this.key,
    partitionKey: partitionKey.present ? partitionKey.value : this.partitionKey,
    value: value.present ? value.value : this.value,
  );
  SettingData copyWithCompanion(SettingCompanion data) {
    return SettingData(
      key: data.key.present ? data.key.value : this.key,
      partitionKey: data.partitionKey.present
          ? data.partitionKey.value
          : this.partitionKey,
      value: data.value.present ? data.value.value : this.value,
    );
  }

  @override
  String toString() {
    return (StringBuffer('SettingData(')
          ..write('key: $key, ')
          ..write('partitionKey: $partitionKey, ')
          ..write('value: $value')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(key, partitionKey, value);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is SettingData &&
          other.key == this.key &&
          other.partitionKey == this.partitionKey &&
          other.value == this.value);
}

class SettingCompanion extends UpdateCompanion<SettingData> {
  final Value<String> key;
  final Value<String?> partitionKey;
  final Value<DriftAny?> value;
  final Value<int> rowid;
  const SettingCompanion({
    this.key = const Value.absent(),
    this.partitionKey = const Value.absent(),
    this.value = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  SettingCompanion.insert({
    required String key,
    this.partitionKey = const Value.absent(),
    this.value = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : key = Value(key);
  static Insertable<SettingData> custom({
    Expression<String>? key,
    Expression<String>? partitionKey,
    Expression<DriftAny>? value,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (key != null) 'key': key,
      if (partitionKey != null) 'partition_key': partitionKey,
      if (value != null) 'value': value,
      if (rowid != null) 'rowid': rowid,
    });
  }

  SettingCompanion copyWith({
    Value<String>? key,
    Value<String?>? partitionKey,
    Value<DriftAny?>? value,
    Value<int>? rowid,
  }) {
    return SettingCompanion(
      key: key ?? this.key,
      partitionKey: partitionKey ?? this.partitionKey,
      value: value ?? this.value,
      rowid: rowid ?? this.rowid,
    );
  }

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

  @override
  String toString() {
    return (StringBuffer('SettingCompanion(')
          ..write('key: $key, ')
          ..write('partitionKey: $partitionKey, ')
          ..write('value: $value, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class IconCache extends Table with TableInfo<IconCache, IconCacheData> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  IconCache(this.attachedDatabase, [this._alias]);
  late final GeneratedColumn<String> origin = GeneratedColumn<String>(
    'origin',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    $customConstraints: 'PRIMARY KEY NOT NULL',
  );
  late final GeneratedColumn<Uint8List> iconData = GeneratedColumn<Uint8List>(
    'icon_data',
    aliasedName,
    false,
    type: DriftSqlType.blob,
    requiredDuringInsert: true,
    $customConstraints: 'NOT NULL',
  );
  late final GeneratedColumn<DateTime> fetchDate = GeneratedColumn<DateTime>(
    'fetch_date',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: true,
    $customConstraints: 'NOT NULL',
  );
  @override
  List<GeneratedColumn> get $columns => [origin, iconData, fetchDate];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'icon_cache';
  @override
  Set<GeneratedColumn> get $primaryKey => {origin};
  @override
  IconCacheData map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return IconCacheData(
      origin: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}origin'],
      )!,
      iconData: attachedDatabase.typeMapping.read(
        DriftSqlType.blob,
        data['${effectivePrefix}icon_data'],
      )!,
      fetchDate: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}fetch_date'],
      )!,
    );
  }

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

  @override
  bool get dontWriteConstraints => true;
}

class IconCacheData extends DataClass implements Insertable<IconCacheData> {
  final String origin;
  final Uint8List iconData;
  final DateTime fetchDate;
  const IconCacheData({
    required this.origin,
    required this.iconData,
    required this.fetchDate,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['origin'] = Variable<String>(origin);
    map['icon_data'] = Variable<Uint8List>(iconData);
    map['fetch_date'] = Variable<DateTime>(fetchDate);
    return map;
  }

  factory IconCacheData.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return IconCacheData(
      origin: serializer.fromJson<String>(json['origin']),
      iconData: serializer.fromJson<Uint8List>(json['icon_data']),
      fetchDate: serializer.fromJson<DateTime>(json['fetch_date']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'origin': serializer.toJson<String>(origin),
      'icon_data': serializer.toJson<Uint8List>(iconData),
      'fetch_date': serializer.toJson<DateTime>(fetchDate),
    };
  }

  IconCacheData copyWith({
    String? origin,
    Uint8List? iconData,
    DateTime? fetchDate,
  }) => IconCacheData(
    origin: origin ?? this.origin,
    iconData: iconData ?? this.iconData,
    fetchDate: fetchDate ?? this.fetchDate,
  );
  IconCacheData copyWithCompanion(IconCacheCompanion data) {
    return IconCacheData(
      origin: data.origin.present ? data.origin.value : this.origin,
      iconData: data.iconData.present ? data.iconData.value : this.iconData,
      fetchDate: data.fetchDate.present ? data.fetchDate.value : this.fetchDate,
    );
  }

  @override
  String toString() {
    return (StringBuffer('IconCacheData(')
          ..write('origin: $origin, ')
          ..write('iconData: $iconData, ')
          ..write('fetchDate: $fetchDate')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode =>
      Object.hash(origin, $driftBlobEquality.hash(iconData), fetchDate);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is IconCacheData &&
          other.origin == this.origin &&
          $driftBlobEquality.equals(other.iconData, this.iconData) &&
          other.fetchDate == this.fetchDate);
}

class IconCacheCompanion extends UpdateCompanion<IconCacheData> {
  final Value<String> origin;
  final Value<Uint8List> iconData;
  final Value<DateTime> fetchDate;
  final Value<int> rowid;
  const IconCacheCompanion({
    this.origin = const Value.absent(),
    this.iconData = const Value.absent(),
    this.fetchDate = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  IconCacheCompanion.insert({
    required String origin,
    required Uint8List iconData,
    required DateTime fetchDate,
    this.rowid = const Value.absent(),
  }) : origin = Value(origin),
       iconData = Value(iconData),
       fetchDate = Value(fetchDate);
  static Insertable<IconCacheData> custom({
    Expression<String>? origin,
    Expression<Uint8List>? iconData,
    Expression<DateTime>? fetchDate,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (origin != null) 'origin': origin,
      if (iconData != null) 'icon_data': iconData,
      if (fetchDate != null) 'fetch_date': fetchDate,
      if (rowid != null) 'rowid': rowid,
    });
  }

  IconCacheCompanion copyWith({
    Value<String>? origin,
    Value<Uint8List>? iconData,
    Value<DateTime>? fetchDate,
    Value<int>? rowid,
  }) {
    return IconCacheCompanion(
      origin: origin ?? this.origin,
      iconData: iconData ?? this.iconData,
      fetchDate: fetchDate ?? this.fetchDate,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (origin.present) {
      map['origin'] = Variable<String>(origin.value);
    }
    if (iconData.present) {
      map['icon_data'] = Variable<Uint8List>(iconData.value);
    }
    if (fetchDate.present) {
      map['fetch_date'] = Variable<DateTime>(fetchDate.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('IconCacheCompanion(')
          ..write('origin: $origin, ')
          ..write('iconData: $iconData, ')
          ..write('fetchDate: $fetchDate, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class Onboarding extends Table with TableInfo<Onboarding, OnboardingData> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  Onboarding(this.attachedDatabase, [this._alias]);
  late final GeneratedColumn<int> revision = GeneratedColumn<int>(
    'revision',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
    $customConstraints: 'NOT NULL',
  );
  late final GeneratedColumn<DateTime> completionDate =
      GeneratedColumn<DateTime>(
        'completion_date',
        aliasedName,
        false,
        type: DriftSqlType.dateTime,
        requiredDuringInsert: true,
        $customConstraints: 'NOT NULL',
      );
  @override
  List<GeneratedColumn> get $columns => [revision, completionDate];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'onboarding';
  @override
  Set<GeneratedColumn> get $primaryKey => const {};
  @override
  OnboardingData map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return OnboardingData(
      revision: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}revision'],
      )!,
      completionDate: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}completion_date'],
      )!,
    );
  }

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

  @override
  bool get dontWriteConstraints => true;
}

class OnboardingData extends DataClass implements Insertable<OnboardingData> {
  final int revision;
  final DateTime completionDate;
  const OnboardingData({required this.revision, required this.completionDate});
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['revision'] = Variable<int>(revision);
    map['completion_date'] = Variable<DateTime>(completionDate);
    return map;
  }

  factory OnboardingData.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return OnboardingData(
      revision: serializer.fromJson<int>(json['revision']),
      completionDate: serializer.fromJson<DateTime>(json['completion_date']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'revision': serializer.toJson<int>(revision),
      'completion_date': serializer.toJson<DateTime>(completionDate),
    };
  }

  OnboardingData copyWith({int? revision, DateTime? completionDate}) =>
      OnboardingData(
        revision: revision ?? this.revision,
        completionDate: completionDate ?? this.completionDate,
      );
  OnboardingData copyWithCompanion(OnboardingCompanion data) {
    return OnboardingData(
      revision: data.revision.present ? data.revision.value : this.revision,
      completionDate: data.completionDate.present
          ? data.completionDate.value
          : this.completionDate,
    );
  }

  @override
  String toString() {
    return (StringBuffer('OnboardingData(')
          ..write('revision: $revision, ')
          ..write('completionDate: $completionDate')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(revision, completionDate);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is OnboardingData &&
          other.revision == this.revision &&
          other.completionDate == this.completionDate);
}

class OnboardingCompanion extends UpdateCompanion<OnboardingData> {
  final Value<int> revision;
  final Value<DateTime> completionDate;
  final Value<int> rowid;
  const OnboardingCompanion({
    this.revision = const Value.absent(),
    this.completionDate = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  OnboardingCompanion.insert({
    required int revision,
    required DateTime completionDate,
    this.rowid = const Value.absent(),
  }) : revision = Value(revision),
       completionDate = Value(completionDate);
  static Insertable<OnboardingData> custom({
    Expression<int>? revision,
    Expression<DateTime>? completionDate,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (revision != null) 'revision': revision,
      if (completionDate != null) 'completion_date': completionDate,
      if (rowid != null) 'rowid': rowid,
    });
  }

  OnboardingCompanion copyWith({
    Value<int>? revision,
    Value<DateTime>? completionDate,
    Value<int>? rowid,
  }) {
    return OnboardingCompanion(
      revision: revision ?? this.revision,
      completionDate: completionDate ?? this.completionDate,
      rowid: rowid ?? this.rowid,
    );
  }

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

  @override
  String toString() {
    return (StringBuffer('OnboardingCompanion(')
          ..write('revision: $revision, ')
          ..write('completionDate: $completionDate, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

abstract class _$UserDatabase extends GeneratedDatabase {
  _$UserDatabase(QueryExecutor e) : super(e);
  $UserDatabaseManager get managers => $UserDatabaseManager(this);
  late final Setting setting = Setting(this);
  late final IconCache iconCache = IconCache(this);
  late final Onboarding onboarding = Onboarding(this);
  late final SettingDao settingDao = SettingDao(this as UserDatabase);
  late final CacheDao cacheDao = CacheDao(this as UserDatabase);
  late final OnboardingDao onboardingDao = OnboardingDao(this as UserDatabase);
  Future<int> evictCacheEntries({required int limit}) {
    return customUpdate(
      'DELETE FROM icon_cache WHERE "rowid" IN (SELECT "rowid" FROM icon_cache ORDER BY fetch_date DESC LIMIT -1 OFFSET ?1)',
      variables: [Variable<int>(limit)],
      updates: {iconCache},
      updateKind: UpdateKind.delete,
    );
  }

  @override
  Iterable<TableInfo<Table, Object?>> get allTables =>
      allSchemaEntities.whereType<TableInfo<Table, Object?>>();
  @override
  List<DatabaseSchemaEntity> get allSchemaEntities => [
    setting,
    iconCache,
    onboarding,
  ];
}

typedef $SettingCreateCompanionBuilder =
    SettingCompanion Function({
      required String key,
      Value<String?> partitionKey,
      Value<DriftAny?> value,
      Value<int> rowid,
    });
typedef $SettingUpdateCompanionBuilder =
    SettingCompanion Function({
      Value<String> key,
      Value<String?> partitionKey,
      Value<DriftAny?> value,
      Value<int> rowid,
    });

class $SettingFilterComposer extends Composer<_$UserDatabase, Setting> {
  $SettingFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get key => $composableBuilder(
    column: $table.key,
    builder: (column) => ColumnFilters(column),
  );

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

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

class $SettingOrderingComposer extends Composer<_$UserDatabase, Setting> {
  $SettingOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get key => $composableBuilder(
    column: $table.key,
    builder: (column) => ColumnOrderings(column),
  );

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

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

class $SettingAnnotationComposer extends Composer<_$UserDatabase, Setting> {
  $SettingAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get key =>
      $composableBuilder(column: $table.key, builder: (column) => column);

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

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

class $SettingTableManager
    extends
        RootTableManager<
          _$UserDatabase,
          Setting,
          SettingData,
          $SettingFilterComposer,
          $SettingOrderingComposer,
          $SettingAnnotationComposer,
          $SettingCreateCompanionBuilder,
          $SettingUpdateCompanionBuilder,
          (SettingData, BaseReferences<_$UserDatabase, Setting, SettingData>),
          SettingData,
          PrefetchHooks Function()
        > {
  $SettingTableManager(_$UserDatabase db, Setting table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $SettingFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $SettingOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $SettingAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> key = const Value.absent(),
                Value<String?> partitionKey = const Value.absent(),
                Value<DriftAny?> value = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => SettingCompanion(
                key: key,
                partitionKey: partitionKey,
                value: value,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String key,
                Value<String?> partitionKey = const Value.absent(),
                Value<DriftAny?> value = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => SettingCompanion.insert(
                key: key,
                partitionKey: partitionKey,
                value: value,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $SettingProcessedTableManager =
    ProcessedTableManager<
      _$UserDatabase,
      Setting,
      SettingData,
      $SettingFilterComposer,
      $SettingOrderingComposer,
      $SettingAnnotationComposer,
      $SettingCreateCompanionBuilder,
      $SettingUpdateCompanionBuilder,
      (SettingData, BaseReferences<_$UserDatabase, Setting, SettingData>),
      SettingData,
      PrefetchHooks Function()
    >;
typedef $IconCacheCreateCompanionBuilder =
    IconCacheCompanion Function({
      required String origin,
      required Uint8List iconData,
      required DateTime fetchDate,
      Value<int> rowid,
    });
typedef $IconCacheUpdateCompanionBuilder =
    IconCacheCompanion Function({
      Value<String> origin,
      Value<Uint8List> iconData,
      Value<DateTime> fetchDate,
      Value<int> rowid,
    });

class $IconCacheFilterComposer extends Composer<_$UserDatabase, IconCache> {
  $IconCacheFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get origin => $composableBuilder(
    column: $table.origin,
    builder: (column) => ColumnFilters(column),
  );

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

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

class $IconCacheOrderingComposer extends Composer<_$UserDatabase, IconCache> {
  $IconCacheOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get origin => $composableBuilder(
    column: $table.origin,
    builder: (column) => ColumnOrderings(column),
  );

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

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

class $IconCacheAnnotationComposer extends Composer<_$UserDatabase, IconCache> {
  $IconCacheAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get origin =>
      $composableBuilder(column: $table.origin, builder: (column) => column);

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

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

class $IconCacheTableManager
    extends
        RootTableManager<
          _$UserDatabase,
          IconCache,
          IconCacheData,
          $IconCacheFilterComposer,
          $IconCacheOrderingComposer,
          $IconCacheAnnotationComposer,
          $IconCacheCreateCompanionBuilder,
          $IconCacheUpdateCompanionBuilder,
          (
            IconCacheData,
            BaseReferences<_$UserDatabase, IconCache, IconCacheData>,
          ),
          IconCacheData,
          PrefetchHooks Function()
        > {
  $IconCacheTableManager(_$UserDatabase db, IconCache table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $IconCacheFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $IconCacheOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $IconCacheAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> origin = const Value.absent(),
                Value<Uint8List> iconData = const Value.absent(),
                Value<DateTime> fetchDate = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => IconCacheCompanion(
                origin: origin,
                iconData: iconData,
                fetchDate: fetchDate,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String origin,
                required Uint8List iconData,
                required DateTime fetchDate,
                Value<int> rowid = const Value.absent(),
              }) => IconCacheCompanion.insert(
                origin: origin,
                iconData: iconData,
                fetchDate: fetchDate,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $IconCacheProcessedTableManager =
    ProcessedTableManager<
      _$UserDatabase,
      IconCache,
      IconCacheData,
      $IconCacheFilterComposer,
      $IconCacheOrderingComposer,
      $IconCacheAnnotationComposer,
      $IconCacheCreateCompanionBuilder,
      $IconCacheUpdateCompanionBuilder,
      (IconCacheData, BaseReferences<_$UserDatabase, IconCache, IconCacheData>),
      IconCacheData,
      PrefetchHooks Function()
    >;
typedef $OnboardingCreateCompanionBuilder =
    OnboardingCompanion Function({
      required int revision,
      required DateTime completionDate,
      Value<int> rowid,
    });
typedef $OnboardingUpdateCompanionBuilder =
    OnboardingCompanion Function({
      Value<int> revision,
      Value<DateTime> completionDate,
      Value<int> rowid,
    });

class $OnboardingFilterComposer extends Composer<_$UserDatabase, Onboarding> {
  $OnboardingFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<int> get revision => $composableBuilder(
    column: $table.revision,
    builder: (column) => ColumnFilters(column),
  );

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

class $OnboardingOrderingComposer extends Composer<_$UserDatabase, Onboarding> {
  $OnboardingOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<int> get revision => $composableBuilder(
    column: $table.revision,
    builder: (column) => ColumnOrderings(column),
  );

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

class $OnboardingAnnotationComposer
    extends Composer<_$UserDatabase, Onboarding> {
  $OnboardingAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<int> get revision =>
      $composableBuilder(column: $table.revision, builder: (column) => column);

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

class $OnboardingTableManager
    extends
        RootTableManager<
          _$UserDatabase,
          Onboarding,
          OnboardingData,
          $OnboardingFilterComposer,
          $OnboardingOrderingComposer,
          $OnboardingAnnotationComposer,
          $OnboardingCreateCompanionBuilder,
          $OnboardingUpdateCompanionBuilder,
          (
            OnboardingData,
            BaseReferences<_$UserDatabase, Onboarding, OnboardingData>,
          ),
          OnboardingData,
          PrefetchHooks Function()
        > {
  $OnboardingTableManager(_$UserDatabase db, Onboarding table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $OnboardingFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $OnboardingOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $OnboardingAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<int> revision = const Value.absent(),
                Value<DateTime> completionDate = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => OnboardingCompanion(
                revision: revision,
                completionDate: completionDate,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required int revision,
                required DateTime completionDate,
                Value<int> rowid = const Value.absent(),
              }) => OnboardingCompanion.insert(
                revision: revision,
                completionDate: completionDate,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $OnboardingProcessedTableManager =
    ProcessedTableManager<
      _$UserDatabase,
      Onboarding,
      OnboardingData,
      $OnboardingFilterComposer,
      $OnboardingOrderingComposer,
      $OnboardingAnnotationComposer,
      $OnboardingCreateCompanionBuilder,
      $OnboardingUpdateCompanionBuilder,
      (
        OnboardingData,
        BaseReferences<_$UserDatabase, Onboarding, OnboardingData>,
      ),
      OnboardingData,
      PrefetchHooks Function()
    >;

class $UserDatabaseManager {
  final _$UserDatabase _db;
  $UserDatabaseManager(this._db);
  $SettingTableManager get setting => $SettingTableManager(_db, _db.setting);
  $IconCacheTableManager get iconCache =>
      $IconCacheTableManager(_db, _db.iconCache);
  $OnboardingTableManager get onboarding =>
      $OnboardingTableManager(_db, _db.onboarding);
}
