// 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