587 lines
22 KiB
Dart
587 lines
22 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'database.dart';
|
|
|
|
// ignore_for_file: type=lint
|
|
class $ConnectedDevicesTable extends ConnectedDevices
|
|
with TableInfo<$ConnectedDevicesTable, ConnectedDevice> {
|
|
@override
|
|
final GeneratedDatabase attachedDatabase;
|
|
final String? _alias;
|
|
$ConnectedDevicesTable(this.attachedDatabase, [this._alias]);
|
|
static const VerificationMeta _idMeta = const VerificationMeta('id');
|
|
@override
|
|
late final GeneratedColumn<int> id = GeneratedColumn<int>(
|
|
'id', aliasedName, false,
|
|
hasAutoIncrement: true,
|
|
type: DriftSqlType.int,
|
|
requiredDuringInsert: false,
|
|
defaultConstraints:
|
|
GeneratedColumn.constraintIsAlways('PRIMARY KEY AUTOINCREMENT'));
|
|
static const VerificationMeta _deviceNameMeta =
|
|
const VerificationMeta('deviceName');
|
|
@override
|
|
late final GeneratedColumn<String> deviceName = GeneratedColumn<String>(
|
|
'device_name', aliasedName, false,
|
|
type: DriftSqlType.string, requiredDuringInsert: true);
|
|
static const VerificationMeta _deviceAddressMeta =
|
|
const VerificationMeta('deviceAddress');
|
|
@override
|
|
late final GeneratedColumn<String> deviceAddress = GeneratedColumn<String>(
|
|
'device_address', aliasedName, false,
|
|
type: DriftSqlType.string, requiredDuringInsert: true);
|
|
static const VerificationMeta _deviceTypeMeta =
|
|
const VerificationMeta('deviceType');
|
|
@override
|
|
late final GeneratedColumn<String> deviceType = GeneratedColumn<String>(
|
|
'device_type', aliasedName, false,
|
|
type: DriftSqlType.string, requiredDuringInsert: true);
|
|
static const VerificationMeta _createdAtMeta =
|
|
const VerificationMeta('createdAt');
|
|
@override
|
|
late final GeneratedColumn<DateTime> createdAt = GeneratedColumn<DateTime>(
|
|
'created_at', aliasedName, false,
|
|
type: DriftSqlType.dateTime,
|
|
requiredDuringInsert: false,
|
|
defaultValue: currentDateAndTime);
|
|
static const VerificationMeta _lastConnectedAtMeta =
|
|
const VerificationMeta('lastConnectedAt');
|
|
@override
|
|
late final GeneratedColumn<DateTime> lastConnectedAt =
|
|
GeneratedColumn<DateTime>('last_connected_at', aliasedName, true,
|
|
type: DriftSqlType.dateTime, requiredDuringInsert: false);
|
|
@override
|
|
List<GeneratedColumn> get $columns =>
|
|
[id, deviceName, deviceAddress, deviceType, createdAt, lastConnectedAt];
|
|
@override
|
|
String get aliasedName => _alias ?? actualTableName;
|
|
@override
|
|
String get actualTableName => $name;
|
|
static const String $name = 'connected_devices';
|
|
@override
|
|
VerificationContext validateIntegrity(Insertable<ConnectedDevice> instance,
|
|
{bool isInserting = false}) {
|
|
final context = VerificationContext();
|
|
final data = instance.toColumns(true);
|
|
if (data.containsKey('id')) {
|
|
context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
|
|
}
|
|
if (data.containsKey('device_name')) {
|
|
context.handle(
|
|
_deviceNameMeta,
|
|
deviceName.isAcceptableOrUnknown(
|
|
data['device_name']!, _deviceNameMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_deviceNameMeta);
|
|
}
|
|
if (data.containsKey('device_address')) {
|
|
context.handle(
|
|
_deviceAddressMeta,
|
|
deviceAddress.isAcceptableOrUnknown(
|
|
data['device_address']!, _deviceAddressMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_deviceAddressMeta);
|
|
}
|
|
if (data.containsKey('device_type')) {
|
|
context.handle(
|
|
_deviceTypeMeta,
|
|
deviceType.isAcceptableOrUnknown(
|
|
data['device_type']!, _deviceTypeMeta));
|
|
} else if (isInserting) {
|
|
context.missing(_deviceTypeMeta);
|
|
}
|
|
if (data.containsKey('created_at')) {
|
|
context.handle(_createdAtMeta,
|
|
createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta));
|
|
}
|
|
if (data.containsKey('last_connected_at')) {
|
|
context.handle(
|
|
_lastConnectedAtMeta,
|
|
lastConnectedAt.isAcceptableOrUnknown(
|
|
data['last_connected_at']!, _lastConnectedAtMeta));
|
|
}
|
|
return context;
|
|
}
|
|
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
ConnectedDevice map(Map<String, dynamic> data, {String? tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
|
|
return ConnectedDevice(
|
|
id: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.int, data['${effectivePrefix}id'])!,
|
|
deviceName: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}device_name'])!,
|
|
deviceAddress: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}device_address'])!,
|
|
deviceType: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.string, data['${effectivePrefix}device_type'])!,
|
|
createdAt: attachedDatabase.typeMapping
|
|
.read(DriftSqlType.dateTime, data['${effectivePrefix}created_at'])!,
|
|
lastConnectedAt: attachedDatabase.typeMapping.read(
|
|
DriftSqlType.dateTime, data['${effectivePrefix}last_connected_at']),
|
|
);
|
|
}
|
|
|
|
@override
|
|
$ConnectedDevicesTable createAlias(String alias) {
|
|
return $ConnectedDevicesTable(attachedDatabase, alias);
|
|
}
|
|
}
|
|
|
|
class ConnectedDevice extends DataClass implements Insertable<ConnectedDevice> {
|
|
final int id;
|
|
final String deviceName;
|
|
final String deviceAddress;
|
|
final String deviceType;
|
|
final DateTime createdAt;
|
|
final DateTime? lastConnectedAt;
|
|
const ConnectedDevice(
|
|
{required this.id,
|
|
required this.deviceName,
|
|
required this.deviceAddress,
|
|
required this.deviceType,
|
|
required this.createdAt,
|
|
this.lastConnectedAt});
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
map['id'] = Variable<int>(id);
|
|
map['device_name'] = Variable<String>(deviceName);
|
|
map['device_address'] = Variable<String>(deviceAddress);
|
|
map['device_type'] = Variable<String>(deviceType);
|
|
map['created_at'] = Variable<DateTime>(createdAt);
|
|
if (!nullToAbsent || lastConnectedAt != null) {
|
|
map['last_connected_at'] = Variable<DateTime>(lastConnectedAt);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
ConnectedDevicesCompanion toCompanion(bool nullToAbsent) {
|
|
return ConnectedDevicesCompanion(
|
|
id: Value(id),
|
|
deviceName: Value(deviceName),
|
|
deviceAddress: Value(deviceAddress),
|
|
deviceType: Value(deviceType),
|
|
createdAt: Value(createdAt),
|
|
lastConnectedAt: lastConnectedAt == null && nullToAbsent
|
|
? const Value.absent()
|
|
: Value(lastConnectedAt),
|
|
);
|
|
}
|
|
|
|
factory ConnectedDevice.fromJson(Map<String, dynamic> json,
|
|
{ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return ConnectedDevice(
|
|
id: serializer.fromJson<int>(json['id']),
|
|
deviceName: serializer.fromJson<String>(json['deviceName']),
|
|
deviceAddress: serializer.fromJson<String>(json['deviceAddress']),
|
|
deviceType: serializer.fromJson<String>(json['deviceType']),
|
|
createdAt: serializer.fromJson<DateTime>(json['createdAt']),
|
|
lastConnectedAt: serializer.fromJson<DateTime?>(json['lastConnectedAt']),
|
|
);
|
|
}
|
|
@override
|
|
Map<String, dynamic> toJson({ValueSerializer? serializer}) {
|
|
serializer ??= driftRuntimeOptions.defaultSerializer;
|
|
return <String, dynamic>{
|
|
'id': serializer.toJson<int>(id),
|
|
'deviceName': serializer.toJson<String>(deviceName),
|
|
'deviceAddress': serializer.toJson<String>(deviceAddress),
|
|
'deviceType': serializer.toJson<String>(deviceType),
|
|
'createdAt': serializer.toJson<DateTime>(createdAt),
|
|
'lastConnectedAt': serializer.toJson<DateTime?>(lastConnectedAt),
|
|
};
|
|
}
|
|
|
|
ConnectedDevice copyWith(
|
|
{int? id,
|
|
String? deviceName,
|
|
String? deviceAddress,
|
|
String? deviceType,
|
|
DateTime? createdAt,
|
|
Value<DateTime?> lastConnectedAt = const Value.absent()}) =>
|
|
ConnectedDevice(
|
|
id: id ?? this.id,
|
|
deviceName: deviceName ?? this.deviceName,
|
|
deviceAddress: deviceAddress ?? this.deviceAddress,
|
|
deviceType: deviceType ?? this.deviceType,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
lastConnectedAt: lastConnectedAt.present
|
|
? lastConnectedAt.value
|
|
: this.lastConnectedAt,
|
|
);
|
|
ConnectedDevice copyWithCompanion(ConnectedDevicesCompanion data) {
|
|
return ConnectedDevice(
|
|
id: data.id.present ? data.id.value : this.id,
|
|
deviceName:
|
|
data.deviceName.present ? data.deviceName.value : this.deviceName,
|
|
deviceAddress: data.deviceAddress.present
|
|
? data.deviceAddress.value
|
|
: this.deviceAddress,
|
|
deviceType:
|
|
data.deviceType.present ? data.deviceType.value : this.deviceType,
|
|
createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
|
|
lastConnectedAt: data.lastConnectedAt.present
|
|
? data.lastConnectedAt.value
|
|
: this.lastConnectedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ConnectedDevice(')
|
|
..write('id: $id, ')
|
|
..write('deviceName: $deviceName, ')
|
|
..write('deviceAddress: $deviceAddress, ')
|
|
..write('deviceType: $deviceType, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('lastConnectedAt: $lastConnectedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => Object.hash(
|
|
id, deviceName, deviceAddress, deviceType, createdAt, lastConnectedAt);
|
|
@override
|
|
bool operator ==(Object other) =>
|
|
identical(this, other) ||
|
|
(other is ConnectedDevice &&
|
|
other.id == this.id &&
|
|
other.deviceName == this.deviceName &&
|
|
other.deviceAddress == this.deviceAddress &&
|
|
other.deviceType == this.deviceType &&
|
|
other.createdAt == this.createdAt &&
|
|
other.lastConnectedAt == this.lastConnectedAt);
|
|
}
|
|
|
|
class ConnectedDevicesCompanion extends UpdateCompanion<ConnectedDevice> {
|
|
final Value<int> id;
|
|
final Value<String> deviceName;
|
|
final Value<String> deviceAddress;
|
|
final Value<String> deviceType;
|
|
final Value<DateTime> createdAt;
|
|
final Value<DateTime?> lastConnectedAt;
|
|
const ConnectedDevicesCompanion({
|
|
this.id = const Value.absent(),
|
|
this.deviceName = const Value.absent(),
|
|
this.deviceAddress = const Value.absent(),
|
|
this.deviceType = const Value.absent(),
|
|
this.createdAt = const Value.absent(),
|
|
this.lastConnectedAt = const Value.absent(),
|
|
});
|
|
ConnectedDevicesCompanion.insert({
|
|
this.id = const Value.absent(),
|
|
required String deviceName,
|
|
required String deviceAddress,
|
|
required String deviceType,
|
|
this.createdAt = const Value.absent(),
|
|
this.lastConnectedAt = const Value.absent(),
|
|
}) : deviceName = Value(deviceName),
|
|
deviceAddress = Value(deviceAddress),
|
|
deviceType = Value(deviceType);
|
|
static Insertable<ConnectedDevice> custom({
|
|
Expression<int>? id,
|
|
Expression<String>? deviceName,
|
|
Expression<String>? deviceAddress,
|
|
Expression<String>? deviceType,
|
|
Expression<DateTime>? createdAt,
|
|
Expression<DateTime>? lastConnectedAt,
|
|
}) {
|
|
return RawValuesInsertable({
|
|
if (id != null) 'id': id,
|
|
if (deviceName != null) 'device_name': deviceName,
|
|
if (deviceAddress != null) 'device_address': deviceAddress,
|
|
if (deviceType != null) 'device_type': deviceType,
|
|
if (createdAt != null) 'created_at': createdAt,
|
|
if (lastConnectedAt != null) 'last_connected_at': lastConnectedAt,
|
|
});
|
|
}
|
|
|
|
ConnectedDevicesCompanion copyWith(
|
|
{Value<int>? id,
|
|
Value<String>? deviceName,
|
|
Value<String>? deviceAddress,
|
|
Value<String>? deviceType,
|
|
Value<DateTime>? createdAt,
|
|
Value<DateTime?>? lastConnectedAt}) {
|
|
return ConnectedDevicesCompanion(
|
|
id: id ?? this.id,
|
|
deviceName: deviceName ?? this.deviceName,
|
|
deviceAddress: deviceAddress ?? this.deviceAddress,
|
|
deviceType: deviceType ?? this.deviceType,
|
|
createdAt: createdAt ?? this.createdAt,
|
|
lastConnectedAt: lastConnectedAt ?? this.lastConnectedAt,
|
|
);
|
|
}
|
|
|
|
@override
|
|
Map<String, Expression> toColumns(bool nullToAbsent) {
|
|
final map = <String, Expression>{};
|
|
if (id.present) {
|
|
map['id'] = Variable<int>(id.value);
|
|
}
|
|
if (deviceName.present) {
|
|
map['device_name'] = Variable<String>(deviceName.value);
|
|
}
|
|
if (deviceAddress.present) {
|
|
map['device_address'] = Variable<String>(deviceAddress.value);
|
|
}
|
|
if (deviceType.present) {
|
|
map['device_type'] = Variable<String>(deviceType.value);
|
|
}
|
|
if (createdAt.present) {
|
|
map['created_at'] = Variable<DateTime>(createdAt.value);
|
|
}
|
|
if (lastConnectedAt.present) {
|
|
map['last_connected_at'] = Variable<DateTime>(lastConnectedAt.value);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('ConnectedDevicesCompanion(')
|
|
..write('id: $id, ')
|
|
..write('deviceName: $deviceName, ')
|
|
..write('deviceAddress: $deviceAddress, ')
|
|
..write('deviceType: $deviceType, ')
|
|
..write('createdAt: $createdAt, ')
|
|
..write('lastConnectedAt: $lastConnectedAt')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
}
|
|
|
|
abstract class _$AppDatabase extends GeneratedDatabase {
|
|
_$AppDatabase(QueryExecutor e) : super(e);
|
|
$AppDatabaseManager get managers => $AppDatabaseManager(this);
|
|
late final $ConnectedDevicesTable connectedDevices =
|
|
$ConnectedDevicesTable(this);
|
|
@override
|
|
Iterable<TableInfo<Table, Object?>> get allTables =>
|
|
allSchemaEntities.whereType<TableInfo<Table, Object?>>();
|
|
@override
|
|
List<DatabaseSchemaEntity> get allSchemaEntities => [connectedDevices];
|
|
}
|
|
|
|
typedef $$ConnectedDevicesTableCreateCompanionBuilder
|
|
= ConnectedDevicesCompanion Function({
|
|
Value<int> id,
|
|
required String deviceName,
|
|
required String deviceAddress,
|
|
required String deviceType,
|
|
Value<DateTime> createdAt,
|
|
Value<DateTime?> lastConnectedAt,
|
|
});
|
|
typedef $$ConnectedDevicesTableUpdateCompanionBuilder
|
|
= ConnectedDevicesCompanion Function({
|
|
Value<int> id,
|
|
Value<String> deviceName,
|
|
Value<String> deviceAddress,
|
|
Value<String> deviceType,
|
|
Value<DateTime> createdAt,
|
|
Value<DateTime?> lastConnectedAt,
|
|
});
|
|
|
|
class $$ConnectedDevicesTableFilterComposer
|
|
extends Composer<_$AppDatabase, $ConnectedDevicesTable> {
|
|
$$ConnectedDevicesTableFilterComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnFilters<int> get id => $composableBuilder(
|
|
column: $table.id, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get deviceName => $composableBuilder(
|
|
column: $table.deviceName, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get deviceAddress => $composableBuilder(
|
|
column: $table.deviceAddress, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<String> get deviceType => $composableBuilder(
|
|
column: $table.deviceType, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnFilters(column));
|
|
|
|
ColumnFilters<DateTime> get lastConnectedAt => $composableBuilder(
|
|
column: $table.lastConnectedAt,
|
|
builder: (column) => ColumnFilters(column));
|
|
}
|
|
|
|
class $$ConnectedDevicesTableOrderingComposer
|
|
extends Composer<_$AppDatabase, $ConnectedDevicesTable> {
|
|
$$ConnectedDevicesTableOrderingComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
ColumnOrderings<int> get id => $composableBuilder(
|
|
column: $table.id, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get deviceName => $composableBuilder(
|
|
column: $table.deviceName, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get deviceAddress => $composableBuilder(
|
|
column: $table.deviceAddress,
|
|
builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<String> get deviceType => $composableBuilder(
|
|
column: $table.deviceType, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<DateTime> get createdAt => $composableBuilder(
|
|
column: $table.createdAt, builder: (column) => ColumnOrderings(column));
|
|
|
|
ColumnOrderings<DateTime> get lastConnectedAt => $composableBuilder(
|
|
column: $table.lastConnectedAt,
|
|
builder: (column) => ColumnOrderings(column));
|
|
}
|
|
|
|
class $$ConnectedDevicesTableAnnotationComposer
|
|
extends Composer<_$AppDatabase, $ConnectedDevicesTable> {
|
|
$$ConnectedDevicesTableAnnotationComposer({
|
|
required super.$db,
|
|
required super.$table,
|
|
super.joinBuilder,
|
|
super.$addJoinBuilderToRootComposer,
|
|
super.$removeJoinBuilderFromRootComposer,
|
|
});
|
|
GeneratedColumn<int> get id =>
|
|
$composableBuilder(column: $table.id, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get deviceName => $composableBuilder(
|
|
column: $table.deviceName, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get deviceAddress => $composableBuilder(
|
|
column: $table.deviceAddress, builder: (column) => column);
|
|
|
|
GeneratedColumn<String> get deviceType => $composableBuilder(
|
|
column: $table.deviceType, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get createdAt =>
|
|
$composableBuilder(column: $table.createdAt, builder: (column) => column);
|
|
|
|
GeneratedColumn<DateTime> get lastConnectedAt => $composableBuilder(
|
|
column: $table.lastConnectedAt, builder: (column) => column);
|
|
}
|
|
|
|
class $$ConnectedDevicesTableTableManager extends RootTableManager<
|
|
_$AppDatabase,
|
|
$ConnectedDevicesTable,
|
|
ConnectedDevice,
|
|
$$ConnectedDevicesTableFilterComposer,
|
|
$$ConnectedDevicesTableOrderingComposer,
|
|
$$ConnectedDevicesTableAnnotationComposer,
|
|
$$ConnectedDevicesTableCreateCompanionBuilder,
|
|
$$ConnectedDevicesTableUpdateCompanionBuilder,
|
|
(
|
|
ConnectedDevice,
|
|
BaseReferences<_$AppDatabase, $ConnectedDevicesTable, ConnectedDevice>
|
|
),
|
|
ConnectedDevice,
|
|
PrefetchHooks Function()> {
|
|
$$ConnectedDevicesTableTableManager(
|
|
_$AppDatabase db, $ConnectedDevicesTable table)
|
|
: super(TableManagerState(
|
|
db: db,
|
|
table: table,
|
|
createFilteringComposer: () =>
|
|
$$ConnectedDevicesTableFilterComposer($db: db, $table: table),
|
|
createOrderingComposer: () =>
|
|
$$ConnectedDevicesTableOrderingComposer($db: db, $table: table),
|
|
createComputedFieldComposer: () =>
|
|
$$ConnectedDevicesTableAnnotationComposer($db: db, $table: table),
|
|
updateCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
Value<String> deviceName = const Value.absent(),
|
|
Value<String> deviceAddress = const Value.absent(),
|
|
Value<String> deviceType = const Value.absent(),
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<DateTime?> lastConnectedAt = const Value.absent(),
|
|
}) =>
|
|
ConnectedDevicesCompanion(
|
|
id: id,
|
|
deviceName: deviceName,
|
|
deviceAddress: deviceAddress,
|
|
deviceType: deviceType,
|
|
createdAt: createdAt,
|
|
lastConnectedAt: lastConnectedAt,
|
|
),
|
|
createCompanionCallback: ({
|
|
Value<int> id = const Value.absent(),
|
|
required String deviceName,
|
|
required String deviceAddress,
|
|
required String deviceType,
|
|
Value<DateTime> createdAt = const Value.absent(),
|
|
Value<DateTime?> lastConnectedAt = const Value.absent(),
|
|
}) =>
|
|
ConnectedDevicesCompanion.insert(
|
|
id: id,
|
|
deviceName: deviceName,
|
|
deviceAddress: deviceAddress,
|
|
deviceType: deviceType,
|
|
createdAt: createdAt,
|
|
lastConnectedAt: lastConnectedAt,
|
|
),
|
|
withReferenceMapper: (p0) => p0
|
|
.map((e) => (e.readTable(table), BaseReferences(db, table, e)))
|
|
.toList(),
|
|
prefetchHooksCallback: null,
|
|
));
|
|
}
|
|
|
|
typedef $$ConnectedDevicesTableProcessedTableManager = ProcessedTableManager<
|
|
_$AppDatabase,
|
|
$ConnectedDevicesTable,
|
|
ConnectedDevice,
|
|
$$ConnectedDevicesTableFilterComposer,
|
|
$$ConnectedDevicesTableOrderingComposer,
|
|
$$ConnectedDevicesTableAnnotationComposer,
|
|
$$ConnectedDevicesTableCreateCompanionBuilder,
|
|
$$ConnectedDevicesTableUpdateCompanionBuilder,
|
|
(
|
|
ConnectedDevice,
|
|
BaseReferences<_$AppDatabase, $ConnectedDevicesTable, ConnectedDevice>
|
|
),
|
|
ConnectedDevice,
|
|
PrefetchHooks Function()>;
|
|
|
|
class $AppDatabaseManager {
|
|
final _$AppDatabase _db;
|
|
$AppDatabaseManager(this._db);
|
|
$$ConnectedDevicesTableTableManager get connectedDevices =>
|
|
$$ConnectedDevicesTableTableManager(_db, _db.connectedDevices);
|
|
}
|
|
|
|
// **************************************************************************
|
|
// RiverpodGenerator
|
|
// **************************************************************************
|
|
|
|
String _$nConnectedDevicesHash() => r'022e744d950bb37c1016266064639e51ce6031b5';
|
|
|
|
/// See also [NConnectedDevices].
|
|
@ProviderFor(NConnectedDevices)
|
|
final nConnectedDevicesProvider = AutoDisposeAsyncNotifierProvider<
|
|
NConnectedDevices, List<ConnectedDevice>>.internal(
|
|
NConnectedDevices.new,
|
|
name: r'nConnectedDevicesProvider',
|
|
debugGetCreateSourceHash: const bool.fromEnvironment('dart.vm.product')
|
|
? null
|
|
: _$nConnectedDevicesHash,
|
|
dependencies: null,
|
|
allTransitiveDependencies: null,
|
|
);
|
|
|
|
typedef _$NConnectedDevices = AutoDisposeAsyncNotifier<List<ConnectedDevice>>;
|
|
// ignore_for_file: type=lint
|
|
// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package
|