// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'app_database.dart';

// ignore_for_file: type=lint
class $ProductsTable extends Products
    with TableInfo<$ProductsTable, ProductRow> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $ProductsTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<String> id = GeneratedColumn<String>(
    'id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _nameMeta = const VerificationMeta('name');
  @override
  late final GeneratedColumn<String> name = GeneratedColumn<String>(
    'name',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _categoryMeta = const VerificationMeta(
    'category',
  );
  @override
  late final GeneratedColumn<String> category = GeneratedColumn<String>(
    'category',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _stockQuantityMeta = const VerificationMeta(
    'stockQuantity',
  );
  @override
  late final GeneratedColumn<int> stockQuantity = GeneratedColumn<int>(
    'stock_quantity',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _lowStockThresholdMeta = const VerificationMeta(
    'lowStockThreshold',
  );
  @override
  late final GeneratedColumn<int> lowStockThreshold = GeneratedColumn<int>(
    'low_stock_threshold',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _infiniteStockMeta = const VerificationMeta(
    'infiniteStock',
  );
  @override
  late final GeneratedColumn<bool> infiniteStock = GeneratedColumn<bool>(
    'infinite_stock',
    aliasedName,
    false,
    type: DriftSqlType.bool,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'CHECK ("infinite_stock" IN (0, 1))',
    ),
    defaultValue: const Constant(false),
  );
  static const VerificationMeta _priceInCentsMeta = const VerificationMeta(
    'priceInCents',
  );
  @override
  late final GeneratedColumn<int> priceInCents = GeneratedColumn<int>(
    'price_in_cents',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _imagePathMeta = const VerificationMeta(
    'imagePath',
  );
  @override
  late final GeneratedColumn<String> imagePath = GeneratedColumn<String>(
    'image_path',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
  );
  static const VerificationMeta _activeMeta = const VerificationMeta('active');
  @override
  late final GeneratedColumn<bool> active = GeneratedColumn<bool>(
    'active',
    aliasedName,
    false,
    type: DriftSqlType.bool,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'CHECK ("active" IN (0, 1))',
    ),
    defaultValue: const Constant(true),
  );
  @override
  List<GeneratedColumn> get $columns => [
    id,
    name,
    category,
    stockQuantity,
    lowStockThreshold,
    infiniteStock,
    priceInCents,
    imagePath,
    active,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'products';
  @override
  VerificationContext validateIntegrity(
    Insertable<ProductRow> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    } else if (isInserting) {
      context.missing(_idMeta);
    }
    if (data.containsKey('name')) {
      context.handle(
        _nameMeta,
        name.isAcceptableOrUnknown(data['name']!, _nameMeta),
      );
    } else if (isInserting) {
      context.missing(_nameMeta);
    }
    if (data.containsKey('category')) {
      context.handle(
        _categoryMeta,
        category.isAcceptableOrUnknown(data['category']!, _categoryMeta),
      );
    } else if (isInserting) {
      context.missing(_categoryMeta);
    }
    if (data.containsKey('stock_quantity')) {
      context.handle(
        _stockQuantityMeta,
        stockQuantity.isAcceptableOrUnknown(
          data['stock_quantity']!,
          _stockQuantityMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_stockQuantityMeta);
    }
    if (data.containsKey('low_stock_threshold')) {
      context.handle(
        _lowStockThresholdMeta,
        lowStockThreshold.isAcceptableOrUnknown(
          data['low_stock_threshold']!,
          _lowStockThresholdMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_lowStockThresholdMeta);
    }
    if (data.containsKey('infinite_stock')) {
      context.handle(
        _infiniteStockMeta,
        infiniteStock.isAcceptableOrUnknown(
          data['infinite_stock']!,
          _infiniteStockMeta,
        ),
      );
    }
    if (data.containsKey('price_in_cents')) {
      context.handle(
        _priceInCentsMeta,
        priceInCents.isAcceptableOrUnknown(
          data['price_in_cents']!,
          _priceInCentsMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_priceInCentsMeta);
    }
    if (data.containsKey('image_path')) {
      context.handle(
        _imagePathMeta,
        imagePath.isAcceptableOrUnknown(data['image_path']!, _imagePathMeta),
      );
    }
    if (data.containsKey('active')) {
      context.handle(
        _activeMeta,
        active.isAcceptableOrUnknown(data['active']!, _activeMeta),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  ProductRow map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return ProductRow(
      id: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}id'],
      )!,
      name: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}name'],
      )!,
      category: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}category'],
      )!,
      stockQuantity: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}stock_quantity'],
      )!,
      lowStockThreshold: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}low_stock_threshold'],
      )!,
      infiniteStock: attachedDatabase.typeMapping.read(
        DriftSqlType.bool,
        data['${effectivePrefix}infinite_stock'],
      )!,
      priceInCents: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}price_in_cents'],
      )!,
      imagePath: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}image_path'],
      ),
      active: attachedDatabase.typeMapping.read(
        DriftSqlType.bool,
        data['${effectivePrefix}active'],
      )!,
    );
  }

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

class ProductRow extends DataClass implements Insertable<ProductRow> {
  final String id;
  final String name;
  final String category;
  final int stockQuantity;
  final int lowStockThreshold;

  /// Products like tap water that are never counted; their stock is ignored.
  final bool infiniteStock;
  final int priceInCents;
  final String? imagePath;
  final bool active;
  const ProductRow({
    required this.id,
    required this.name,
    required this.category,
    required this.stockQuantity,
    required this.lowStockThreshold,
    required this.infiniteStock,
    required this.priceInCents,
    this.imagePath,
    required this.active,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<String>(id);
    map['name'] = Variable<String>(name);
    map['category'] = Variable<String>(category);
    map['stock_quantity'] = Variable<int>(stockQuantity);
    map['low_stock_threshold'] = Variable<int>(lowStockThreshold);
    map['infinite_stock'] = Variable<bool>(infiniteStock);
    map['price_in_cents'] = Variable<int>(priceInCents);
    if (!nullToAbsent || imagePath != null) {
      map['image_path'] = Variable<String>(imagePath);
    }
    map['active'] = Variable<bool>(active);
    return map;
  }

  ProductsCompanion toCompanion(bool nullToAbsent) {
    return ProductsCompanion(
      id: Value(id),
      name: Value(name),
      category: Value(category),
      stockQuantity: Value(stockQuantity),
      lowStockThreshold: Value(lowStockThreshold),
      infiniteStock: Value(infiniteStock),
      priceInCents: Value(priceInCents),
      imagePath: imagePath == null && nullToAbsent
          ? const Value.absent()
          : Value(imagePath),
      active: Value(active),
    );
  }

  factory ProductRow.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return ProductRow(
      id: serializer.fromJson<String>(json['id']),
      name: serializer.fromJson<String>(json['name']),
      category: serializer.fromJson<String>(json['category']),
      stockQuantity: serializer.fromJson<int>(json['stockQuantity']),
      lowStockThreshold: serializer.fromJson<int>(json['lowStockThreshold']),
      infiniteStock: serializer.fromJson<bool>(json['infiniteStock']),
      priceInCents: serializer.fromJson<int>(json['priceInCents']),
      imagePath: serializer.fromJson<String?>(json['imagePath']),
      active: serializer.fromJson<bool>(json['active']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'id': serializer.toJson<String>(id),
      'name': serializer.toJson<String>(name),
      'category': serializer.toJson<String>(category),
      'stockQuantity': serializer.toJson<int>(stockQuantity),
      'lowStockThreshold': serializer.toJson<int>(lowStockThreshold),
      'infiniteStock': serializer.toJson<bool>(infiniteStock),
      'priceInCents': serializer.toJson<int>(priceInCents),
      'imagePath': serializer.toJson<String?>(imagePath),
      'active': serializer.toJson<bool>(active),
    };
  }

  ProductRow copyWith({
    String? id,
    String? name,
    String? category,
    int? stockQuantity,
    int? lowStockThreshold,
    bool? infiniteStock,
    int? priceInCents,
    Value<String?> imagePath = const Value.absent(),
    bool? active,
  }) => ProductRow(
    id: id ?? this.id,
    name: name ?? this.name,
    category: category ?? this.category,
    stockQuantity: stockQuantity ?? this.stockQuantity,
    lowStockThreshold: lowStockThreshold ?? this.lowStockThreshold,
    infiniteStock: infiniteStock ?? this.infiniteStock,
    priceInCents: priceInCents ?? this.priceInCents,
    imagePath: imagePath.present ? imagePath.value : this.imagePath,
    active: active ?? this.active,
  );
  ProductRow copyWithCompanion(ProductsCompanion data) {
    return ProductRow(
      id: data.id.present ? data.id.value : this.id,
      name: data.name.present ? data.name.value : this.name,
      category: data.category.present ? data.category.value : this.category,
      stockQuantity: data.stockQuantity.present
          ? data.stockQuantity.value
          : this.stockQuantity,
      lowStockThreshold: data.lowStockThreshold.present
          ? data.lowStockThreshold.value
          : this.lowStockThreshold,
      infiniteStock: data.infiniteStock.present
          ? data.infiniteStock.value
          : this.infiniteStock,
      priceInCents: data.priceInCents.present
          ? data.priceInCents.value
          : this.priceInCents,
      imagePath: data.imagePath.present ? data.imagePath.value : this.imagePath,
      active: data.active.present ? data.active.value : this.active,
    );
  }

  @override
  String toString() {
    return (StringBuffer('ProductRow(')
          ..write('id: $id, ')
          ..write('name: $name, ')
          ..write('category: $category, ')
          ..write('stockQuantity: $stockQuantity, ')
          ..write('lowStockThreshold: $lowStockThreshold, ')
          ..write('infiniteStock: $infiniteStock, ')
          ..write('priceInCents: $priceInCents, ')
          ..write('imagePath: $imagePath, ')
          ..write('active: $active')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(
    id,
    name,
    category,
    stockQuantity,
    lowStockThreshold,
    infiniteStock,
    priceInCents,
    imagePath,
    active,
  );
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is ProductRow &&
          other.id == this.id &&
          other.name == this.name &&
          other.category == this.category &&
          other.stockQuantity == this.stockQuantity &&
          other.lowStockThreshold == this.lowStockThreshold &&
          other.infiniteStock == this.infiniteStock &&
          other.priceInCents == this.priceInCents &&
          other.imagePath == this.imagePath &&
          other.active == this.active);
}

class ProductsCompanion extends UpdateCompanion<ProductRow> {
  final Value<String> id;
  final Value<String> name;
  final Value<String> category;
  final Value<int> stockQuantity;
  final Value<int> lowStockThreshold;
  final Value<bool> infiniteStock;
  final Value<int> priceInCents;
  final Value<String?> imagePath;
  final Value<bool> active;
  final Value<int> rowid;
  const ProductsCompanion({
    this.id = const Value.absent(),
    this.name = const Value.absent(),
    this.category = const Value.absent(),
    this.stockQuantity = const Value.absent(),
    this.lowStockThreshold = const Value.absent(),
    this.infiniteStock = const Value.absent(),
    this.priceInCents = const Value.absent(),
    this.imagePath = const Value.absent(),
    this.active = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  ProductsCompanion.insert({
    required String id,
    required String name,
    required String category,
    required int stockQuantity,
    required int lowStockThreshold,
    this.infiniteStock = const Value.absent(),
    required int priceInCents,
    this.imagePath = const Value.absent(),
    this.active = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : id = Value(id),
       name = Value(name),
       category = Value(category),
       stockQuantity = Value(stockQuantity),
       lowStockThreshold = Value(lowStockThreshold),
       priceInCents = Value(priceInCents);
  static Insertable<ProductRow> custom({
    Expression<String>? id,
    Expression<String>? name,
    Expression<String>? category,
    Expression<int>? stockQuantity,
    Expression<int>? lowStockThreshold,
    Expression<bool>? infiniteStock,
    Expression<int>? priceInCents,
    Expression<String>? imagePath,
    Expression<bool>? active,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (name != null) 'name': name,
      if (category != null) 'category': category,
      if (stockQuantity != null) 'stock_quantity': stockQuantity,
      if (lowStockThreshold != null) 'low_stock_threshold': lowStockThreshold,
      if (infiniteStock != null) 'infinite_stock': infiniteStock,
      if (priceInCents != null) 'price_in_cents': priceInCents,
      if (imagePath != null) 'image_path': imagePath,
      if (active != null) 'active': active,
      if (rowid != null) 'rowid': rowid,
    });
  }

  ProductsCompanion copyWith({
    Value<String>? id,
    Value<String>? name,
    Value<String>? category,
    Value<int>? stockQuantity,
    Value<int>? lowStockThreshold,
    Value<bool>? infiniteStock,
    Value<int>? priceInCents,
    Value<String?>? imagePath,
    Value<bool>? active,
    Value<int>? rowid,
  }) {
    return ProductsCompanion(
      id: id ?? this.id,
      name: name ?? this.name,
      category: category ?? this.category,
      stockQuantity: stockQuantity ?? this.stockQuantity,
      lowStockThreshold: lowStockThreshold ?? this.lowStockThreshold,
      infiniteStock: infiniteStock ?? this.infiniteStock,
      priceInCents: priceInCents ?? this.priceInCents,
      imagePath: imagePath ?? this.imagePath,
      active: active ?? this.active,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<String>(id.value);
    }
    if (name.present) {
      map['name'] = Variable<String>(name.value);
    }
    if (category.present) {
      map['category'] = Variable<String>(category.value);
    }
    if (stockQuantity.present) {
      map['stock_quantity'] = Variable<int>(stockQuantity.value);
    }
    if (lowStockThreshold.present) {
      map['low_stock_threshold'] = Variable<int>(lowStockThreshold.value);
    }
    if (infiniteStock.present) {
      map['infinite_stock'] = Variable<bool>(infiniteStock.value);
    }
    if (priceInCents.present) {
      map['price_in_cents'] = Variable<int>(priceInCents.value);
    }
    if (imagePath.present) {
      map['image_path'] = Variable<String>(imagePath.value);
    }
    if (active.present) {
      map['active'] = Variable<bool>(active.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('ProductsCompanion(')
          ..write('id: $id, ')
          ..write('name: $name, ')
          ..write('category: $category, ')
          ..write('stockQuantity: $stockQuantity, ')
          ..write('lowStockThreshold: $lowStockThreshold, ')
          ..write('infiniteStock: $infiniteStock, ')
          ..write('priceInCents: $priceInCents, ')
          ..write('imagePath: $imagePath, ')
          ..write('active: $active, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $BarTabsTable extends BarTabs with TableInfo<$BarTabsTable, BarTabRow> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $BarTabsTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<String> id = GeneratedColumn<String>(
    'id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _customerNameMeta = const VerificationMeta(
    'customerName',
  );
  @override
  late final GeneratedColumn<String> customerName = GeneratedColumn<String>(
    'customer_name',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _openedAtMeta = const VerificationMeta(
    'openedAt',
  );
  @override
  late final GeneratedColumn<DateTime> openedAt = GeneratedColumn<DateTime>(
    'opened_at',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _versionMeta = const VerificationMeta(
    'version',
  );
  @override
  late final GeneratedColumn<int> version = GeneratedColumn<int>(
    'version',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultValue: const Constant(0),
  );
  @override
  List<GeneratedColumn> get $columns => [id, customerName, openedAt, version];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'bar_tabs';
  @override
  VerificationContext validateIntegrity(
    Insertable<BarTabRow> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    } else if (isInserting) {
      context.missing(_idMeta);
    }
    if (data.containsKey('customer_name')) {
      context.handle(
        _customerNameMeta,
        customerName.isAcceptableOrUnknown(
          data['customer_name']!,
          _customerNameMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_customerNameMeta);
    }
    if (data.containsKey('opened_at')) {
      context.handle(
        _openedAtMeta,
        openedAt.isAcceptableOrUnknown(data['opened_at']!, _openedAtMeta),
      );
    } else if (isInserting) {
      context.missing(_openedAtMeta);
    }
    if (data.containsKey('version')) {
      context.handle(
        _versionMeta,
        version.isAcceptableOrUnknown(data['version']!, _versionMeta),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  BarTabRow map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return BarTabRow(
      id: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}id'],
      )!,
      customerName: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}customer_name'],
      )!,
      openedAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}opened_at'],
      )!,
      version: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}version'],
      )!,
    );
  }

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

class BarTabRow extends DataClass implements Insertable<BarTabRow> {
  final String id;
  final String customerName;
  final DateTime openedAt;
  final int version;
  const BarTabRow({
    required this.id,
    required this.customerName,
    required this.openedAt,
    required this.version,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<String>(id);
    map['customer_name'] = Variable<String>(customerName);
    map['opened_at'] = Variable<DateTime>(openedAt);
    map['version'] = Variable<int>(version);
    return map;
  }

  BarTabsCompanion toCompanion(bool nullToAbsent) {
    return BarTabsCompanion(
      id: Value(id),
      customerName: Value(customerName),
      openedAt: Value(openedAt),
      version: Value(version),
    );
  }

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

  BarTabRow copyWith({
    String? id,
    String? customerName,
    DateTime? openedAt,
    int? version,
  }) => BarTabRow(
    id: id ?? this.id,
    customerName: customerName ?? this.customerName,
    openedAt: openedAt ?? this.openedAt,
    version: version ?? this.version,
  );
  BarTabRow copyWithCompanion(BarTabsCompanion data) {
    return BarTabRow(
      id: data.id.present ? data.id.value : this.id,
      customerName: data.customerName.present
          ? data.customerName.value
          : this.customerName,
      openedAt: data.openedAt.present ? data.openedAt.value : this.openedAt,
      version: data.version.present ? data.version.value : this.version,
    );
  }

  @override
  String toString() {
    return (StringBuffer('BarTabRow(')
          ..write('id: $id, ')
          ..write('customerName: $customerName, ')
          ..write('openedAt: $openedAt, ')
          ..write('version: $version')
          ..write(')'))
        .toString();
  }

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

class BarTabsCompanion extends UpdateCompanion<BarTabRow> {
  final Value<String> id;
  final Value<String> customerName;
  final Value<DateTime> openedAt;
  final Value<int> version;
  final Value<int> rowid;
  const BarTabsCompanion({
    this.id = const Value.absent(),
    this.customerName = const Value.absent(),
    this.openedAt = const Value.absent(),
    this.version = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  BarTabsCompanion.insert({
    required String id,
    required String customerName,
    required DateTime openedAt,
    this.version = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : id = Value(id),
       customerName = Value(customerName),
       openedAt = Value(openedAt);
  static Insertable<BarTabRow> custom({
    Expression<String>? id,
    Expression<String>? customerName,
    Expression<DateTime>? openedAt,
    Expression<int>? version,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (customerName != null) 'customer_name': customerName,
      if (openedAt != null) 'opened_at': openedAt,
      if (version != null) 'version': version,
      if (rowid != null) 'rowid': rowid,
    });
  }

  BarTabsCompanion copyWith({
    Value<String>? id,
    Value<String>? customerName,
    Value<DateTime>? openedAt,
    Value<int>? version,
    Value<int>? rowid,
  }) {
    return BarTabsCompanion(
      id: id ?? this.id,
      customerName: customerName ?? this.customerName,
      openedAt: openedAt ?? this.openedAt,
      version: version ?? this.version,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<String>(id.value);
    }
    if (customerName.present) {
      map['customer_name'] = Variable<String>(customerName.value);
    }
    if (openedAt.present) {
      map['opened_at'] = Variable<DateTime>(openedAt.value);
    }
    if (version.present) {
      map['version'] = Variable<int>(version.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('BarTabsCompanion(')
          ..write('id: $id, ')
          ..write('customerName: $customerName, ')
          ..write('openedAt: $openedAt, ')
          ..write('version: $version, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $TabItemsTable extends TabItems
    with TableInfo<$TabItemsTable, TabItemRow> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $TabItemsTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<String> id = GeneratedColumn<String>(
    'id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _tabIdMeta = const VerificationMeta('tabId');
  @override
  late final GeneratedColumn<String> tabId = GeneratedColumn<String>(
    'tab_id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'REFERENCES bar_tabs (id) ON DELETE CASCADE',
    ),
  );
  static const VerificationMeta _productIdMeta = const VerificationMeta(
    'productId',
  );
  @override
  late final GeneratedColumn<String> productId = GeneratedColumn<String>(
    'product_id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'REFERENCES products (id)',
    ),
  );
  static const VerificationMeta _productNameMeta = const VerificationMeta(
    'productName',
  );
  @override
  late final GeneratedColumn<String> productName = GeneratedColumn<String>(
    'product_name',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _quantityMeta = const VerificationMeta(
    'quantity',
  );
  @override
  late final GeneratedColumn<int> quantity = GeneratedColumn<int>(
    'quantity',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _unitPriceInCentsMeta = const VerificationMeta(
    'unitPriceInCents',
  );
  @override
  late final GeneratedColumn<int> unitPriceInCents = GeneratedColumn<int>(
    'unit_price_in_cents',
    aliasedName,
    false,
    type: DriftSqlType.int,
    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: true,
  );
  @override
  List<GeneratedColumn> get $columns => [
    id,
    tabId,
    productId,
    productName,
    quantity,
    unitPriceInCents,
    createdAt,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'tab_items';
  @override
  VerificationContext validateIntegrity(
    Insertable<TabItemRow> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    } else if (isInserting) {
      context.missing(_idMeta);
    }
    if (data.containsKey('tab_id')) {
      context.handle(
        _tabIdMeta,
        tabId.isAcceptableOrUnknown(data['tab_id']!, _tabIdMeta),
      );
    } else if (isInserting) {
      context.missing(_tabIdMeta);
    }
    if (data.containsKey('product_id')) {
      context.handle(
        _productIdMeta,
        productId.isAcceptableOrUnknown(data['product_id']!, _productIdMeta),
      );
    } else if (isInserting) {
      context.missing(_productIdMeta);
    }
    if (data.containsKey('product_name')) {
      context.handle(
        _productNameMeta,
        productName.isAcceptableOrUnknown(
          data['product_name']!,
          _productNameMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_productNameMeta);
    }
    if (data.containsKey('quantity')) {
      context.handle(
        _quantityMeta,
        quantity.isAcceptableOrUnknown(data['quantity']!, _quantityMeta),
      );
    } else if (isInserting) {
      context.missing(_quantityMeta);
    }
    if (data.containsKey('unit_price_in_cents')) {
      context.handle(
        _unitPriceInCentsMeta,
        unitPriceInCents.isAcceptableOrUnknown(
          data['unit_price_in_cents']!,
          _unitPriceInCentsMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_unitPriceInCentsMeta);
    }
    if (data.containsKey('created_at')) {
      context.handle(
        _createdAtMeta,
        createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
      );
    } else if (isInserting) {
      context.missing(_createdAtMeta);
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  TabItemRow map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return TabItemRow(
      id: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}id'],
      )!,
      tabId: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}tab_id'],
      )!,
      productId: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}product_id'],
      )!,
      productName: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}product_name'],
      )!,
      quantity: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}quantity'],
      )!,
      unitPriceInCents: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}unit_price_in_cents'],
      )!,
      createdAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}created_at'],
      )!,
    );
  }

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

class TabItemRow extends DataClass implements Insertable<TabItemRow> {
  final String id;
  final String tabId;
  final String productId;
  final String productName;
  final int quantity;
  final int unitPriceInCents;
  final DateTime createdAt;
  const TabItemRow({
    required this.id,
    required this.tabId,
    required this.productId,
    required this.productName,
    required this.quantity,
    required this.unitPriceInCents,
    required this.createdAt,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<String>(id);
    map['tab_id'] = Variable<String>(tabId);
    map['product_id'] = Variable<String>(productId);
    map['product_name'] = Variable<String>(productName);
    map['quantity'] = Variable<int>(quantity);
    map['unit_price_in_cents'] = Variable<int>(unitPriceInCents);
    map['created_at'] = Variable<DateTime>(createdAt);
    return map;
  }

  TabItemsCompanion toCompanion(bool nullToAbsent) {
    return TabItemsCompanion(
      id: Value(id),
      tabId: Value(tabId),
      productId: Value(productId),
      productName: Value(productName),
      quantity: Value(quantity),
      unitPriceInCents: Value(unitPriceInCents),
      createdAt: Value(createdAt),
    );
  }

  factory TabItemRow.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return TabItemRow(
      id: serializer.fromJson<String>(json['id']),
      tabId: serializer.fromJson<String>(json['tabId']),
      productId: serializer.fromJson<String>(json['productId']),
      productName: serializer.fromJson<String>(json['productName']),
      quantity: serializer.fromJson<int>(json['quantity']),
      unitPriceInCents: serializer.fromJson<int>(json['unitPriceInCents']),
      createdAt: serializer.fromJson<DateTime>(json['createdAt']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'id': serializer.toJson<String>(id),
      'tabId': serializer.toJson<String>(tabId),
      'productId': serializer.toJson<String>(productId),
      'productName': serializer.toJson<String>(productName),
      'quantity': serializer.toJson<int>(quantity),
      'unitPriceInCents': serializer.toJson<int>(unitPriceInCents),
      'createdAt': serializer.toJson<DateTime>(createdAt),
    };
  }

  TabItemRow copyWith({
    String? id,
    String? tabId,
    String? productId,
    String? productName,
    int? quantity,
    int? unitPriceInCents,
    DateTime? createdAt,
  }) => TabItemRow(
    id: id ?? this.id,
    tabId: tabId ?? this.tabId,
    productId: productId ?? this.productId,
    productName: productName ?? this.productName,
    quantity: quantity ?? this.quantity,
    unitPriceInCents: unitPriceInCents ?? this.unitPriceInCents,
    createdAt: createdAt ?? this.createdAt,
  );
  TabItemRow copyWithCompanion(TabItemsCompanion data) {
    return TabItemRow(
      id: data.id.present ? data.id.value : this.id,
      tabId: data.tabId.present ? data.tabId.value : this.tabId,
      productId: data.productId.present ? data.productId.value : this.productId,
      productName: data.productName.present
          ? data.productName.value
          : this.productName,
      quantity: data.quantity.present ? data.quantity.value : this.quantity,
      unitPriceInCents: data.unitPriceInCents.present
          ? data.unitPriceInCents.value
          : this.unitPriceInCents,
      createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
    );
  }

  @override
  String toString() {
    return (StringBuffer('TabItemRow(')
          ..write('id: $id, ')
          ..write('tabId: $tabId, ')
          ..write('productId: $productId, ')
          ..write('productName: $productName, ')
          ..write('quantity: $quantity, ')
          ..write('unitPriceInCents: $unitPriceInCents, ')
          ..write('createdAt: $createdAt')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(
    id,
    tabId,
    productId,
    productName,
    quantity,
    unitPriceInCents,
    createdAt,
  );
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is TabItemRow &&
          other.id == this.id &&
          other.tabId == this.tabId &&
          other.productId == this.productId &&
          other.productName == this.productName &&
          other.quantity == this.quantity &&
          other.unitPriceInCents == this.unitPriceInCents &&
          other.createdAt == this.createdAt);
}

class TabItemsCompanion extends UpdateCompanion<TabItemRow> {
  final Value<String> id;
  final Value<String> tabId;
  final Value<String> productId;
  final Value<String> productName;
  final Value<int> quantity;
  final Value<int> unitPriceInCents;
  final Value<DateTime> createdAt;
  final Value<int> rowid;
  const TabItemsCompanion({
    this.id = const Value.absent(),
    this.tabId = const Value.absent(),
    this.productId = const Value.absent(),
    this.productName = const Value.absent(),
    this.quantity = const Value.absent(),
    this.unitPriceInCents = const Value.absent(),
    this.createdAt = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  TabItemsCompanion.insert({
    required String id,
    required String tabId,
    required String productId,
    required String productName,
    required int quantity,
    required int unitPriceInCents,
    required DateTime createdAt,
    this.rowid = const Value.absent(),
  }) : id = Value(id),
       tabId = Value(tabId),
       productId = Value(productId),
       productName = Value(productName),
       quantity = Value(quantity),
       unitPriceInCents = Value(unitPriceInCents),
       createdAt = Value(createdAt);
  static Insertable<TabItemRow> custom({
    Expression<String>? id,
    Expression<String>? tabId,
    Expression<String>? productId,
    Expression<String>? productName,
    Expression<int>? quantity,
    Expression<int>? unitPriceInCents,
    Expression<DateTime>? createdAt,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (tabId != null) 'tab_id': tabId,
      if (productId != null) 'product_id': productId,
      if (productName != null) 'product_name': productName,
      if (quantity != null) 'quantity': quantity,
      if (unitPriceInCents != null) 'unit_price_in_cents': unitPriceInCents,
      if (createdAt != null) 'created_at': createdAt,
      if (rowid != null) 'rowid': rowid,
    });
  }

  TabItemsCompanion copyWith({
    Value<String>? id,
    Value<String>? tabId,
    Value<String>? productId,
    Value<String>? productName,
    Value<int>? quantity,
    Value<int>? unitPriceInCents,
    Value<DateTime>? createdAt,
    Value<int>? rowid,
  }) {
    return TabItemsCompanion(
      id: id ?? this.id,
      tabId: tabId ?? this.tabId,
      productId: productId ?? this.productId,
      productName: productName ?? this.productName,
      quantity: quantity ?? this.quantity,
      unitPriceInCents: unitPriceInCents ?? this.unitPriceInCents,
      createdAt: createdAt ?? this.createdAt,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<String>(id.value);
    }
    if (tabId.present) {
      map['tab_id'] = Variable<String>(tabId.value);
    }
    if (productId.present) {
      map['product_id'] = Variable<String>(productId.value);
    }
    if (productName.present) {
      map['product_name'] = Variable<String>(productName.value);
    }
    if (quantity.present) {
      map['quantity'] = Variable<int>(quantity.value);
    }
    if (unitPriceInCents.present) {
      map['unit_price_in_cents'] = Variable<int>(unitPriceInCents.value);
    }
    if (createdAt.present) {
      map['created_at'] = Variable<DateTime>(createdAt.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('TabItemsCompanion(')
          ..write('id: $id, ')
          ..write('tabId: $tabId, ')
          ..write('productId: $productId, ')
          ..write('productName: $productName, ')
          ..write('quantity: $quantity, ')
          ..write('unitPriceInCents: $unitPriceInCents, ')
          ..write('createdAt: $createdAt, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $TabItemPurchasesTable extends TabItemPurchases
    with TableInfo<$TabItemPurchasesTable, TabItemPurchaseRow> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $TabItemPurchasesTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<String> id = GeneratedColumn<String>(
    'id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _tabItemIdMeta = const VerificationMeta(
    'tabItemId',
  );
  @override
  late final GeneratedColumn<String> tabItemId = GeneratedColumn<String>(
    'tab_item_id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'REFERENCES tab_items (id) ON DELETE CASCADE',
    ),
  );
  static const VerificationMeta _purchasedAtMeta = const VerificationMeta(
    'purchasedAt',
  );
  @override
  late final GeneratedColumn<DateTime> purchasedAt = GeneratedColumn<DateTime>(
    'purchased_at',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _removedAtMeta = const VerificationMeta(
    'removedAt',
  );
  @override
  late final GeneratedColumn<DateTime> removedAt = GeneratedColumn<DateTime>(
    'removed_at',
    aliasedName,
    true,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: false,
  );
  @override
  List<GeneratedColumn> get $columns => [id, tabItemId, purchasedAt, removedAt];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'tab_item_purchases';
  @override
  VerificationContext validateIntegrity(
    Insertable<TabItemPurchaseRow> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    } else if (isInserting) {
      context.missing(_idMeta);
    }
    if (data.containsKey('tab_item_id')) {
      context.handle(
        _tabItemIdMeta,
        tabItemId.isAcceptableOrUnknown(data['tab_item_id']!, _tabItemIdMeta),
      );
    } else if (isInserting) {
      context.missing(_tabItemIdMeta);
    }
    if (data.containsKey('purchased_at')) {
      context.handle(
        _purchasedAtMeta,
        purchasedAt.isAcceptableOrUnknown(
          data['purchased_at']!,
          _purchasedAtMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_purchasedAtMeta);
    }
    if (data.containsKey('removed_at')) {
      context.handle(
        _removedAtMeta,
        removedAt.isAcceptableOrUnknown(data['removed_at']!, _removedAtMeta),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  TabItemPurchaseRow map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return TabItemPurchaseRow(
      id: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}id'],
      )!,
      tabItemId: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}tab_item_id'],
      )!,
      purchasedAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}purchased_at'],
      )!,
      removedAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}removed_at'],
      ),
    );
  }

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

class TabItemPurchaseRow extends DataClass
    implements Insertable<TabItemPurchaseRow> {
  final String id;
  final String tabItemId;
  final DateTime purchasedAt;
  final DateTime? removedAt;
  const TabItemPurchaseRow({
    required this.id,
    required this.tabItemId,
    required this.purchasedAt,
    this.removedAt,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<String>(id);
    map['tab_item_id'] = Variable<String>(tabItemId);
    map['purchased_at'] = Variable<DateTime>(purchasedAt);
    if (!nullToAbsent || removedAt != null) {
      map['removed_at'] = Variable<DateTime>(removedAt);
    }
    return map;
  }

  TabItemPurchasesCompanion toCompanion(bool nullToAbsent) {
    return TabItemPurchasesCompanion(
      id: Value(id),
      tabItemId: Value(tabItemId),
      purchasedAt: Value(purchasedAt),
      removedAt: removedAt == null && nullToAbsent
          ? const Value.absent()
          : Value(removedAt),
    );
  }

  factory TabItemPurchaseRow.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return TabItemPurchaseRow(
      id: serializer.fromJson<String>(json['id']),
      tabItemId: serializer.fromJson<String>(json['tabItemId']),
      purchasedAt: serializer.fromJson<DateTime>(json['purchasedAt']),
      removedAt: serializer.fromJson<DateTime?>(json['removedAt']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'id': serializer.toJson<String>(id),
      'tabItemId': serializer.toJson<String>(tabItemId),
      'purchasedAt': serializer.toJson<DateTime>(purchasedAt),
      'removedAt': serializer.toJson<DateTime?>(removedAt),
    };
  }

  TabItemPurchaseRow copyWith({
    String? id,
    String? tabItemId,
    DateTime? purchasedAt,
    Value<DateTime?> removedAt = const Value.absent(),
  }) => TabItemPurchaseRow(
    id: id ?? this.id,
    tabItemId: tabItemId ?? this.tabItemId,
    purchasedAt: purchasedAt ?? this.purchasedAt,
    removedAt: removedAt.present ? removedAt.value : this.removedAt,
  );
  TabItemPurchaseRow copyWithCompanion(TabItemPurchasesCompanion data) {
    return TabItemPurchaseRow(
      id: data.id.present ? data.id.value : this.id,
      tabItemId: data.tabItemId.present ? data.tabItemId.value : this.tabItemId,
      purchasedAt: data.purchasedAt.present
          ? data.purchasedAt.value
          : this.purchasedAt,
      removedAt: data.removedAt.present ? data.removedAt.value : this.removedAt,
    );
  }

  @override
  String toString() {
    return (StringBuffer('TabItemPurchaseRow(')
          ..write('id: $id, ')
          ..write('tabItemId: $tabItemId, ')
          ..write('purchasedAt: $purchasedAt, ')
          ..write('removedAt: $removedAt')
          ..write(')'))
        .toString();
  }

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

class TabItemPurchasesCompanion extends UpdateCompanion<TabItemPurchaseRow> {
  final Value<String> id;
  final Value<String> tabItemId;
  final Value<DateTime> purchasedAt;
  final Value<DateTime?> removedAt;
  final Value<int> rowid;
  const TabItemPurchasesCompanion({
    this.id = const Value.absent(),
    this.tabItemId = const Value.absent(),
    this.purchasedAt = const Value.absent(),
    this.removedAt = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  TabItemPurchasesCompanion.insert({
    required String id,
    required String tabItemId,
    required DateTime purchasedAt,
    this.removedAt = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : id = Value(id),
       tabItemId = Value(tabItemId),
       purchasedAt = Value(purchasedAt);
  static Insertable<TabItemPurchaseRow> custom({
    Expression<String>? id,
    Expression<String>? tabItemId,
    Expression<DateTime>? purchasedAt,
    Expression<DateTime>? removedAt,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (tabItemId != null) 'tab_item_id': tabItemId,
      if (purchasedAt != null) 'purchased_at': purchasedAt,
      if (removedAt != null) 'removed_at': removedAt,
      if (rowid != null) 'rowid': rowid,
    });
  }

  TabItemPurchasesCompanion copyWith({
    Value<String>? id,
    Value<String>? tabItemId,
    Value<DateTime>? purchasedAt,
    Value<DateTime?>? removedAt,
    Value<int>? rowid,
  }) {
    return TabItemPurchasesCompanion(
      id: id ?? this.id,
      tabItemId: tabItemId ?? this.tabItemId,
      purchasedAt: purchasedAt ?? this.purchasedAt,
      removedAt: removedAt ?? this.removedAt,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<String>(id.value);
    }
    if (tabItemId.present) {
      map['tab_item_id'] = Variable<String>(tabItemId.value);
    }
    if (purchasedAt.present) {
      map['purchased_at'] = Variable<DateTime>(purchasedAt.value);
    }
    if (removedAt.present) {
      map['removed_at'] = Variable<DateTime>(removedAt.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('TabItemPurchasesCompanion(')
          ..write('id: $id, ')
          ..write('tabItemId: $tabItemId, ')
          ..write('purchasedAt: $purchasedAt, ')
          ..write('removedAt: $removedAt, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $ClosedTabsTable extends ClosedTabs
    with TableInfo<$ClosedTabsTable, ClosedTabsRow> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $ClosedTabsTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<String> id = GeneratedColumn<String>(
    'id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _originalTabIdMeta = const VerificationMeta(
    'originalTabId',
  );
  @override
  late final GeneratedColumn<String> originalTabId = GeneratedColumn<String>(
    'original_tab_id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _customerNameMeta = const VerificationMeta(
    'customerName',
  );
  @override
  late final GeneratedColumn<String> customerName = GeneratedColumn<String>(
    'customer_name',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _closedAtMeta = const VerificationMeta(
    'closedAt',
  );
  @override
  late final GeneratedColumn<DateTime> closedAt = GeneratedColumn<DateTime>(
    'closed_at',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: true,
  );
  @override
  late final GeneratedColumnWithTypeConverter<PaymentMethod, String>
  paymentMethod = GeneratedColumn<String>(
    'payment_method',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    defaultValue: const Constant('cash'),
  ).withConverter<PaymentMethod>($ClosedTabsTable.$converterpaymentMethod);
  @override
  List<GeneratedColumn> get $columns => [
    id,
    originalTabId,
    customerName,
    closedAt,
    paymentMethod,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'closed_tabs';
  @override
  VerificationContext validateIntegrity(
    Insertable<ClosedTabsRow> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    } else if (isInserting) {
      context.missing(_idMeta);
    }
    if (data.containsKey('original_tab_id')) {
      context.handle(
        _originalTabIdMeta,
        originalTabId.isAcceptableOrUnknown(
          data['original_tab_id']!,
          _originalTabIdMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_originalTabIdMeta);
    }
    if (data.containsKey('customer_name')) {
      context.handle(
        _customerNameMeta,
        customerName.isAcceptableOrUnknown(
          data['customer_name']!,
          _customerNameMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_customerNameMeta);
    }
    if (data.containsKey('closed_at')) {
      context.handle(
        _closedAtMeta,
        closedAt.isAcceptableOrUnknown(data['closed_at']!, _closedAtMeta),
      );
    } else if (isInserting) {
      context.missing(_closedAtMeta);
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  ClosedTabsRow map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return ClosedTabsRow(
      id: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}id'],
      )!,
      originalTabId: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}original_tab_id'],
      )!,
      customerName: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}customer_name'],
      )!,
      closedAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}closed_at'],
      )!,
      paymentMethod: $ClosedTabsTable.$converterpaymentMethod.fromSql(
        attachedDatabase.typeMapping.read(
          DriftSqlType.string,
          data['${effectivePrefix}payment_method'],
        )!,
      ),
    );
  }

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

  static TypeConverter<PaymentMethod, String> $converterpaymentMethod =
      const PaymentMethodConverter();
}

class ClosedTabsRow extends DataClass implements Insertable<ClosedTabsRow> {
  final String id;
  final String originalTabId;
  final String customerName;
  final DateTime closedAt;
  final PaymentMethod paymentMethod;
  const ClosedTabsRow({
    required this.id,
    required this.originalTabId,
    required this.customerName,
    required this.closedAt,
    required this.paymentMethod,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<String>(id);
    map['original_tab_id'] = Variable<String>(originalTabId);
    map['customer_name'] = Variable<String>(customerName);
    map['closed_at'] = Variable<DateTime>(closedAt);
    {
      map['payment_method'] = Variable<String>(
        $ClosedTabsTable.$converterpaymentMethod.toSql(paymentMethod),
      );
    }
    return map;
  }

  ClosedTabsCompanion toCompanion(bool nullToAbsent) {
    return ClosedTabsCompanion(
      id: Value(id),
      originalTabId: Value(originalTabId),
      customerName: Value(customerName),
      closedAt: Value(closedAt),
      paymentMethod: Value(paymentMethod),
    );
  }

  factory ClosedTabsRow.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return ClosedTabsRow(
      id: serializer.fromJson<String>(json['id']),
      originalTabId: serializer.fromJson<String>(json['originalTabId']),
      customerName: serializer.fromJson<String>(json['customerName']),
      closedAt: serializer.fromJson<DateTime>(json['closedAt']),
      paymentMethod: serializer.fromJson<PaymentMethod>(json['paymentMethod']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'id': serializer.toJson<String>(id),
      'originalTabId': serializer.toJson<String>(originalTabId),
      'customerName': serializer.toJson<String>(customerName),
      'closedAt': serializer.toJson<DateTime>(closedAt),
      'paymentMethod': serializer.toJson<PaymentMethod>(paymentMethod),
    };
  }

  ClosedTabsRow copyWith({
    String? id,
    String? originalTabId,
    String? customerName,
    DateTime? closedAt,
    PaymentMethod? paymentMethod,
  }) => ClosedTabsRow(
    id: id ?? this.id,
    originalTabId: originalTabId ?? this.originalTabId,
    customerName: customerName ?? this.customerName,
    closedAt: closedAt ?? this.closedAt,
    paymentMethod: paymentMethod ?? this.paymentMethod,
  );
  ClosedTabsRow copyWithCompanion(ClosedTabsCompanion data) {
    return ClosedTabsRow(
      id: data.id.present ? data.id.value : this.id,
      originalTabId: data.originalTabId.present
          ? data.originalTabId.value
          : this.originalTabId,
      customerName: data.customerName.present
          ? data.customerName.value
          : this.customerName,
      closedAt: data.closedAt.present ? data.closedAt.value : this.closedAt,
      paymentMethod: data.paymentMethod.present
          ? data.paymentMethod.value
          : this.paymentMethod,
    );
  }

  @override
  String toString() {
    return (StringBuffer('ClosedTabsRow(')
          ..write('id: $id, ')
          ..write('originalTabId: $originalTabId, ')
          ..write('customerName: $customerName, ')
          ..write('closedAt: $closedAt, ')
          ..write('paymentMethod: $paymentMethod')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode =>
      Object.hash(id, originalTabId, customerName, closedAt, paymentMethod);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is ClosedTabsRow &&
          other.id == this.id &&
          other.originalTabId == this.originalTabId &&
          other.customerName == this.customerName &&
          other.closedAt == this.closedAt &&
          other.paymentMethod == this.paymentMethod);
}

class ClosedTabsCompanion extends UpdateCompanion<ClosedTabsRow> {
  final Value<String> id;
  final Value<String> originalTabId;
  final Value<String> customerName;
  final Value<DateTime> closedAt;
  final Value<PaymentMethod> paymentMethod;
  final Value<int> rowid;
  const ClosedTabsCompanion({
    this.id = const Value.absent(),
    this.originalTabId = const Value.absent(),
    this.customerName = const Value.absent(),
    this.closedAt = const Value.absent(),
    this.paymentMethod = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  ClosedTabsCompanion.insert({
    required String id,
    required String originalTabId,
    required String customerName,
    required DateTime closedAt,
    this.paymentMethod = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : id = Value(id),
       originalTabId = Value(originalTabId),
       customerName = Value(customerName),
       closedAt = Value(closedAt);
  static Insertable<ClosedTabsRow> custom({
    Expression<String>? id,
    Expression<String>? originalTabId,
    Expression<String>? customerName,
    Expression<DateTime>? closedAt,
    Expression<String>? paymentMethod,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (originalTabId != null) 'original_tab_id': originalTabId,
      if (customerName != null) 'customer_name': customerName,
      if (closedAt != null) 'closed_at': closedAt,
      if (paymentMethod != null) 'payment_method': paymentMethod,
      if (rowid != null) 'rowid': rowid,
    });
  }

  ClosedTabsCompanion copyWith({
    Value<String>? id,
    Value<String>? originalTabId,
    Value<String>? customerName,
    Value<DateTime>? closedAt,
    Value<PaymentMethod>? paymentMethod,
    Value<int>? rowid,
  }) {
    return ClosedTabsCompanion(
      id: id ?? this.id,
      originalTabId: originalTabId ?? this.originalTabId,
      customerName: customerName ?? this.customerName,
      closedAt: closedAt ?? this.closedAt,
      paymentMethod: paymentMethod ?? this.paymentMethod,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<String>(id.value);
    }
    if (originalTabId.present) {
      map['original_tab_id'] = Variable<String>(originalTabId.value);
    }
    if (customerName.present) {
      map['customer_name'] = Variable<String>(customerName.value);
    }
    if (closedAt.present) {
      map['closed_at'] = Variable<DateTime>(closedAt.value);
    }
    if (paymentMethod.present) {
      map['payment_method'] = Variable<String>(
        $ClosedTabsTable.$converterpaymentMethod.toSql(paymentMethod.value),
      );
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('ClosedTabsCompanion(')
          ..write('id: $id, ')
          ..write('originalTabId: $originalTabId, ')
          ..write('customerName: $customerName, ')
          ..write('closedAt: $closedAt, ')
          ..write('paymentMethod: $paymentMethod, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $ClosedTabItemsTable extends ClosedTabItems
    with TableInfo<$ClosedTabItemsTable, ClosedTabItemRow> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $ClosedTabItemsTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<String> id = GeneratedColumn<String>(
    'id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _closedTabIdMeta = const VerificationMeta(
    'closedTabId',
  );
  @override
  late final GeneratedColumn<String> closedTabId = GeneratedColumn<String>(
    'closed_tab_id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _productIdMeta = const VerificationMeta(
    'productId',
  );
  @override
  late final GeneratedColumn<String> productId = GeneratedColumn<String>(
    'product_id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _productNameMeta = const VerificationMeta(
    'productName',
  );
  @override
  late final GeneratedColumn<String> productName = GeneratedColumn<String>(
    'product_name',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _quantityMeta = const VerificationMeta(
    'quantity',
  );
  @override
  late final GeneratedColumn<int> quantity = GeneratedColumn<int>(
    'quantity',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _unitPriceInCentsMeta = const VerificationMeta(
    'unitPriceInCents',
  );
  @override
  late final GeneratedColumn<int> unitPriceInCents = GeneratedColumn<int>(
    'unit_price_in_cents',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _purchasedAtMeta = const VerificationMeta(
    'purchasedAt',
  );
  @override
  late final GeneratedColumn<DateTime> purchasedAt = GeneratedColumn<DateTime>(
    'purchased_at',
    aliasedName,
    true,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: false,
  );
  static const VerificationMeta _removedAtMeta = const VerificationMeta(
    'removedAt',
  );
  @override
  late final GeneratedColumn<DateTime> removedAt = GeneratedColumn<DateTime>(
    'removed_at',
    aliasedName,
    true,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: false,
  );
  @override
  List<GeneratedColumn> get $columns => [
    id,
    closedTabId,
    productId,
    productName,
    quantity,
    unitPriceInCents,
    purchasedAt,
    removedAt,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'closed_tab_items';
  @override
  VerificationContext validateIntegrity(
    Insertable<ClosedTabItemRow> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    } else if (isInserting) {
      context.missing(_idMeta);
    }
    if (data.containsKey('closed_tab_id')) {
      context.handle(
        _closedTabIdMeta,
        closedTabId.isAcceptableOrUnknown(
          data['closed_tab_id']!,
          _closedTabIdMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_closedTabIdMeta);
    }
    if (data.containsKey('product_id')) {
      context.handle(
        _productIdMeta,
        productId.isAcceptableOrUnknown(data['product_id']!, _productIdMeta),
      );
    } else if (isInserting) {
      context.missing(_productIdMeta);
    }
    if (data.containsKey('product_name')) {
      context.handle(
        _productNameMeta,
        productName.isAcceptableOrUnknown(
          data['product_name']!,
          _productNameMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_productNameMeta);
    }
    if (data.containsKey('quantity')) {
      context.handle(
        _quantityMeta,
        quantity.isAcceptableOrUnknown(data['quantity']!, _quantityMeta),
      );
    } else if (isInserting) {
      context.missing(_quantityMeta);
    }
    if (data.containsKey('unit_price_in_cents')) {
      context.handle(
        _unitPriceInCentsMeta,
        unitPriceInCents.isAcceptableOrUnknown(
          data['unit_price_in_cents']!,
          _unitPriceInCentsMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_unitPriceInCentsMeta);
    }
    if (data.containsKey('purchased_at')) {
      context.handle(
        _purchasedAtMeta,
        purchasedAt.isAcceptableOrUnknown(
          data['purchased_at']!,
          _purchasedAtMeta,
        ),
      );
    }
    if (data.containsKey('removed_at')) {
      context.handle(
        _removedAtMeta,
        removedAt.isAcceptableOrUnknown(data['removed_at']!, _removedAtMeta),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  ClosedTabItemRow map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return ClosedTabItemRow(
      id: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}id'],
      )!,
      closedTabId: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}closed_tab_id'],
      )!,
      productId: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}product_id'],
      )!,
      productName: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}product_name'],
      )!,
      quantity: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}quantity'],
      )!,
      unitPriceInCents: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}unit_price_in_cents'],
      )!,
      purchasedAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}purchased_at'],
      ),
      removedAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}removed_at'],
      ),
    );
  }

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

class ClosedTabItemRow extends DataClass
    implements Insertable<ClosedTabItemRow> {
  final String id;
  final String closedTabId;
  final String productId;
  final String productName;
  final int quantity;
  final int unitPriceInCents;
  final DateTime? purchasedAt;
  final DateTime? removedAt;
  const ClosedTabItemRow({
    required this.id,
    required this.closedTabId,
    required this.productId,
    required this.productName,
    required this.quantity,
    required this.unitPriceInCents,
    this.purchasedAt,
    this.removedAt,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<String>(id);
    map['closed_tab_id'] = Variable<String>(closedTabId);
    map['product_id'] = Variable<String>(productId);
    map['product_name'] = Variable<String>(productName);
    map['quantity'] = Variable<int>(quantity);
    map['unit_price_in_cents'] = Variable<int>(unitPriceInCents);
    if (!nullToAbsent || purchasedAt != null) {
      map['purchased_at'] = Variable<DateTime>(purchasedAt);
    }
    if (!nullToAbsent || removedAt != null) {
      map['removed_at'] = Variable<DateTime>(removedAt);
    }
    return map;
  }

  ClosedTabItemsCompanion toCompanion(bool nullToAbsent) {
    return ClosedTabItemsCompanion(
      id: Value(id),
      closedTabId: Value(closedTabId),
      productId: Value(productId),
      productName: Value(productName),
      quantity: Value(quantity),
      unitPriceInCents: Value(unitPriceInCents),
      purchasedAt: purchasedAt == null && nullToAbsent
          ? const Value.absent()
          : Value(purchasedAt),
      removedAt: removedAt == null && nullToAbsent
          ? const Value.absent()
          : Value(removedAt),
    );
  }

  factory ClosedTabItemRow.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return ClosedTabItemRow(
      id: serializer.fromJson<String>(json['id']),
      closedTabId: serializer.fromJson<String>(json['closedTabId']),
      productId: serializer.fromJson<String>(json['productId']),
      productName: serializer.fromJson<String>(json['productName']),
      quantity: serializer.fromJson<int>(json['quantity']),
      unitPriceInCents: serializer.fromJson<int>(json['unitPriceInCents']),
      purchasedAt: serializer.fromJson<DateTime?>(json['purchasedAt']),
      removedAt: serializer.fromJson<DateTime?>(json['removedAt']),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'id': serializer.toJson<String>(id),
      'closedTabId': serializer.toJson<String>(closedTabId),
      'productId': serializer.toJson<String>(productId),
      'productName': serializer.toJson<String>(productName),
      'quantity': serializer.toJson<int>(quantity),
      'unitPriceInCents': serializer.toJson<int>(unitPriceInCents),
      'purchasedAt': serializer.toJson<DateTime?>(purchasedAt),
      'removedAt': serializer.toJson<DateTime?>(removedAt),
    };
  }

  ClosedTabItemRow copyWith({
    String? id,
    String? closedTabId,
    String? productId,
    String? productName,
    int? quantity,
    int? unitPriceInCents,
    Value<DateTime?> purchasedAt = const Value.absent(),
    Value<DateTime?> removedAt = const Value.absent(),
  }) => ClosedTabItemRow(
    id: id ?? this.id,
    closedTabId: closedTabId ?? this.closedTabId,
    productId: productId ?? this.productId,
    productName: productName ?? this.productName,
    quantity: quantity ?? this.quantity,
    unitPriceInCents: unitPriceInCents ?? this.unitPriceInCents,
    purchasedAt: purchasedAt.present ? purchasedAt.value : this.purchasedAt,
    removedAt: removedAt.present ? removedAt.value : this.removedAt,
  );
  ClosedTabItemRow copyWithCompanion(ClosedTabItemsCompanion data) {
    return ClosedTabItemRow(
      id: data.id.present ? data.id.value : this.id,
      closedTabId: data.closedTabId.present
          ? data.closedTabId.value
          : this.closedTabId,
      productId: data.productId.present ? data.productId.value : this.productId,
      productName: data.productName.present
          ? data.productName.value
          : this.productName,
      quantity: data.quantity.present ? data.quantity.value : this.quantity,
      unitPriceInCents: data.unitPriceInCents.present
          ? data.unitPriceInCents.value
          : this.unitPriceInCents,
      purchasedAt: data.purchasedAt.present
          ? data.purchasedAt.value
          : this.purchasedAt,
      removedAt: data.removedAt.present ? data.removedAt.value : this.removedAt,
    );
  }

  @override
  String toString() {
    return (StringBuffer('ClosedTabItemRow(')
          ..write('id: $id, ')
          ..write('closedTabId: $closedTabId, ')
          ..write('productId: $productId, ')
          ..write('productName: $productName, ')
          ..write('quantity: $quantity, ')
          ..write('unitPriceInCents: $unitPriceInCents, ')
          ..write('purchasedAt: $purchasedAt, ')
          ..write('removedAt: $removedAt')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(
    id,
    closedTabId,
    productId,
    productName,
    quantity,
    unitPriceInCents,
    purchasedAt,
    removedAt,
  );
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is ClosedTabItemRow &&
          other.id == this.id &&
          other.closedTabId == this.closedTabId &&
          other.productId == this.productId &&
          other.productName == this.productName &&
          other.quantity == this.quantity &&
          other.unitPriceInCents == this.unitPriceInCents &&
          other.purchasedAt == this.purchasedAt &&
          other.removedAt == this.removedAt);
}

class ClosedTabItemsCompanion extends UpdateCompanion<ClosedTabItemRow> {
  final Value<String> id;
  final Value<String> closedTabId;
  final Value<String> productId;
  final Value<String> productName;
  final Value<int> quantity;
  final Value<int> unitPriceInCents;
  final Value<DateTime?> purchasedAt;
  final Value<DateTime?> removedAt;
  final Value<int> rowid;
  const ClosedTabItemsCompanion({
    this.id = const Value.absent(),
    this.closedTabId = const Value.absent(),
    this.productId = const Value.absent(),
    this.productName = const Value.absent(),
    this.quantity = const Value.absent(),
    this.unitPriceInCents = const Value.absent(),
    this.purchasedAt = const Value.absent(),
    this.removedAt = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  ClosedTabItemsCompanion.insert({
    required String id,
    required String closedTabId,
    required String productId,
    required String productName,
    required int quantity,
    required int unitPriceInCents,
    this.purchasedAt = const Value.absent(),
    this.removedAt = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : id = Value(id),
       closedTabId = Value(closedTabId),
       productId = Value(productId),
       productName = Value(productName),
       quantity = Value(quantity),
       unitPriceInCents = Value(unitPriceInCents);
  static Insertable<ClosedTabItemRow> custom({
    Expression<String>? id,
    Expression<String>? closedTabId,
    Expression<String>? productId,
    Expression<String>? productName,
    Expression<int>? quantity,
    Expression<int>? unitPriceInCents,
    Expression<DateTime>? purchasedAt,
    Expression<DateTime>? removedAt,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (closedTabId != null) 'closed_tab_id': closedTabId,
      if (productId != null) 'product_id': productId,
      if (productName != null) 'product_name': productName,
      if (quantity != null) 'quantity': quantity,
      if (unitPriceInCents != null) 'unit_price_in_cents': unitPriceInCents,
      if (purchasedAt != null) 'purchased_at': purchasedAt,
      if (removedAt != null) 'removed_at': removedAt,
      if (rowid != null) 'rowid': rowid,
    });
  }

  ClosedTabItemsCompanion copyWith({
    Value<String>? id,
    Value<String>? closedTabId,
    Value<String>? productId,
    Value<String>? productName,
    Value<int>? quantity,
    Value<int>? unitPriceInCents,
    Value<DateTime?>? purchasedAt,
    Value<DateTime?>? removedAt,
    Value<int>? rowid,
  }) {
    return ClosedTabItemsCompanion(
      id: id ?? this.id,
      closedTabId: closedTabId ?? this.closedTabId,
      productId: productId ?? this.productId,
      productName: productName ?? this.productName,
      quantity: quantity ?? this.quantity,
      unitPriceInCents: unitPriceInCents ?? this.unitPriceInCents,
      purchasedAt: purchasedAt ?? this.purchasedAt,
      removedAt: removedAt ?? this.removedAt,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<String>(id.value);
    }
    if (closedTabId.present) {
      map['closed_tab_id'] = Variable<String>(closedTabId.value);
    }
    if (productId.present) {
      map['product_id'] = Variable<String>(productId.value);
    }
    if (productName.present) {
      map['product_name'] = Variable<String>(productName.value);
    }
    if (quantity.present) {
      map['quantity'] = Variable<int>(quantity.value);
    }
    if (unitPriceInCents.present) {
      map['unit_price_in_cents'] = Variable<int>(unitPriceInCents.value);
    }
    if (purchasedAt.present) {
      map['purchased_at'] = Variable<DateTime>(purchasedAt.value);
    }
    if (removedAt.present) {
      map['removed_at'] = Variable<DateTime>(removedAt.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('ClosedTabItemsCompanion(')
          ..write('id: $id, ')
          ..write('closedTabId: $closedTabId, ')
          ..write('productId: $productId, ')
          ..write('productName: $productName, ')
          ..write('quantity: $quantity, ')
          ..write('unitPriceInCents: $unitPriceInCents, ')
          ..write('purchasedAt: $purchasedAt, ')
          ..write('removedAt: $removedAt, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $AppSettingsTableTable extends AppSettingsTable
    with TableInfo<$AppSettingsTableTable, AppSettingsRow> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $AppSettingsTableTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<String> id = GeneratedColumn<String>(
    'id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _pinRequiredMeta = const VerificationMeta(
    'pinRequired',
  );
  @override
  late final GeneratedColumn<bool> pinRequired = GeneratedColumn<bool>(
    'pin_required',
    aliasedName,
    false,
    type: DriftSqlType.bool,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'CHECK ("pin_required" IN (0, 1))',
    ),
    defaultValue: const Constant(false),
  );
  static const VerificationMeta _autoLockEnabledMeta = const VerificationMeta(
    'autoLockEnabled',
  );
  @override
  late final GeneratedColumn<bool> autoLockEnabled = GeneratedColumn<bool>(
    'auto_lock_enabled',
    aliasedName,
    false,
    type: DriftSqlType.bool,
    requiredDuringInsert: false,
    defaultConstraints: GeneratedColumn.constraintIsAlways(
      'CHECK ("auto_lock_enabled" IN (0, 1))',
    ),
    defaultValue: const Constant(true),
  );
  static const VerificationMeta _themeModeMeta = const VerificationMeta(
    'themeMode',
  );
  @override
  late final GeneratedColumn<String> themeMode = GeneratedColumn<String>(
    'theme_mode',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    defaultValue: const Constant('system'),
  );
  static const VerificationMeta _languageMeta = const VerificationMeta(
    'language',
  );
  @override
  late final GeneratedColumn<String> language = GeneratedColumn<String>(
    'language',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
    defaultValue: const Constant('system'),
  );
  static const VerificationMeta _barGridRowsMeta = const VerificationMeta(
    'barGridRows',
  );
  @override
  late final GeneratedColumn<int> barGridRows = GeneratedColumn<int>(
    'bar_grid_rows',
    aliasedName,
    false,
    type: DriftSqlType.int,
    requiredDuringInsert: false,
    defaultValue: const Constant(3),
  );
  @override
  List<GeneratedColumn> get $columns => [
    id,
    pinRequired,
    autoLockEnabled,
    themeMode,
    language,
    barGridRows,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'app_settings';
  @override
  VerificationContext validateIntegrity(
    Insertable<AppSettingsRow> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    } else if (isInserting) {
      context.missing(_idMeta);
    }
    if (data.containsKey('pin_required')) {
      context.handle(
        _pinRequiredMeta,
        pinRequired.isAcceptableOrUnknown(
          data['pin_required']!,
          _pinRequiredMeta,
        ),
      );
    }
    if (data.containsKey('auto_lock_enabled')) {
      context.handle(
        _autoLockEnabledMeta,
        autoLockEnabled.isAcceptableOrUnknown(
          data['auto_lock_enabled']!,
          _autoLockEnabledMeta,
        ),
      );
    }
    if (data.containsKey('theme_mode')) {
      context.handle(
        _themeModeMeta,
        themeMode.isAcceptableOrUnknown(data['theme_mode']!, _themeModeMeta),
      );
    }
    if (data.containsKey('language')) {
      context.handle(
        _languageMeta,
        language.isAcceptableOrUnknown(data['language']!, _languageMeta),
      );
    }
    if (data.containsKey('bar_grid_rows')) {
      context.handle(
        _barGridRowsMeta,
        barGridRows.isAcceptableOrUnknown(
          data['bar_grid_rows']!,
          _barGridRowsMeta,
        ),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  AppSettingsRow map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return AppSettingsRow(
      id: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}id'],
      )!,
      pinRequired: attachedDatabase.typeMapping.read(
        DriftSqlType.bool,
        data['${effectivePrefix}pin_required'],
      )!,
      autoLockEnabled: attachedDatabase.typeMapping.read(
        DriftSqlType.bool,
        data['${effectivePrefix}auto_lock_enabled'],
      )!,
      themeMode: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}theme_mode'],
      )!,
      language: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}language'],
      )!,
      barGridRows: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}bar_grid_rows'],
      )!,
    );
  }

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

class AppSettingsRow extends DataClass implements Insertable<AppSettingsRow> {
  final String id;
  final bool pinRequired;
  final bool autoLockEnabled;
  final String themeMode;
  final String language;
  final int barGridRows;
  const AppSettingsRow({
    required this.id,
    required this.pinRequired,
    required this.autoLockEnabled,
    required this.themeMode,
    required this.language,
    required this.barGridRows,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<String>(id);
    map['pin_required'] = Variable<bool>(pinRequired);
    map['auto_lock_enabled'] = Variable<bool>(autoLockEnabled);
    map['theme_mode'] = Variable<String>(themeMode);
    map['language'] = Variable<String>(language);
    map['bar_grid_rows'] = Variable<int>(barGridRows);
    return map;
  }

  AppSettingsTableCompanion toCompanion(bool nullToAbsent) {
    return AppSettingsTableCompanion(
      id: Value(id),
      pinRequired: Value(pinRequired),
      autoLockEnabled: Value(autoLockEnabled),
      themeMode: Value(themeMode),
      language: Value(language),
      barGridRows: Value(barGridRows),
    );
  }

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

  AppSettingsRow copyWith({
    String? id,
    bool? pinRequired,
    bool? autoLockEnabled,
    String? themeMode,
    String? language,
    int? barGridRows,
  }) => AppSettingsRow(
    id: id ?? this.id,
    pinRequired: pinRequired ?? this.pinRequired,
    autoLockEnabled: autoLockEnabled ?? this.autoLockEnabled,
    themeMode: themeMode ?? this.themeMode,
    language: language ?? this.language,
    barGridRows: barGridRows ?? this.barGridRows,
  );
  AppSettingsRow copyWithCompanion(AppSettingsTableCompanion data) {
    return AppSettingsRow(
      id: data.id.present ? data.id.value : this.id,
      pinRequired: data.pinRequired.present
          ? data.pinRequired.value
          : this.pinRequired,
      autoLockEnabled: data.autoLockEnabled.present
          ? data.autoLockEnabled.value
          : this.autoLockEnabled,
      themeMode: data.themeMode.present ? data.themeMode.value : this.themeMode,
      language: data.language.present ? data.language.value : this.language,
      barGridRows: data.barGridRows.present
          ? data.barGridRows.value
          : this.barGridRows,
    );
  }

  @override
  String toString() {
    return (StringBuffer('AppSettingsRow(')
          ..write('id: $id, ')
          ..write('pinRequired: $pinRequired, ')
          ..write('autoLockEnabled: $autoLockEnabled, ')
          ..write('themeMode: $themeMode, ')
          ..write('language: $language, ')
          ..write('barGridRows: $barGridRows')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(
    id,
    pinRequired,
    autoLockEnabled,
    themeMode,
    language,
    barGridRows,
  );
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is AppSettingsRow &&
          other.id == this.id &&
          other.pinRequired == this.pinRequired &&
          other.autoLockEnabled == this.autoLockEnabled &&
          other.themeMode == this.themeMode &&
          other.language == this.language &&
          other.barGridRows == this.barGridRows);
}

class AppSettingsTableCompanion extends UpdateCompanion<AppSettingsRow> {
  final Value<String> id;
  final Value<bool> pinRequired;
  final Value<bool> autoLockEnabled;
  final Value<String> themeMode;
  final Value<String> language;
  final Value<int> barGridRows;
  final Value<int> rowid;
  const AppSettingsTableCompanion({
    this.id = const Value.absent(),
    this.pinRequired = const Value.absent(),
    this.autoLockEnabled = const Value.absent(),
    this.themeMode = const Value.absent(),
    this.language = const Value.absent(),
    this.barGridRows = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  AppSettingsTableCompanion.insert({
    required String id,
    this.pinRequired = const Value.absent(),
    this.autoLockEnabled = const Value.absent(),
    this.themeMode = const Value.absent(),
    this.language = const Value.absent(),
    this.barGridRows = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : id = Value(id);
  static Insertable<AppSettingsRow> custom({
    Expression<String>? id,
    Expression<bool>? pinRequired,
    Expression<bool>? autoLockEnabled,
    Expression<String>? themeMode,
    Expression<String>? language,
    Expression<int>? barGridRows,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (id != null) 'id': id,
      if (pinRequired != null) 'pin_required': pinRequired,
      if (autoLockEnabled != null) 'auto_lock_enabled': autoLockEnabled,
      if (themeMode != null) 'theme_mode': themeMode,
      if (language != null) 'language': language,
      if (barGridRows != null) 'bar_grid_rows': barGridRows,
      if (rowid != null) 'rowid': rowid,
    });
  }

  AppSettingsTableCompanion copyWith({
    Value<String>? id,
    Value<bool>? pinRequired,
    Value<bool>? autoLockEnabled,
    Value<String>? themeMode,
    Value<String>? language,
    Value<int>? barGridRows,
    Value<int>? rowid,
  }) {
    return AppSettingsTableCompanion(
      id: id ?? this.id,
      pinRequired: pinRequired ?? this.pinRequired,
      autoLockEnabled: autoLockEnabled ?? this.autoLockEnabled,
      themeMode: themeMode ?? this.themeMode,
      language: language ?? this.language,
      barGridRows: barGridRows ?? this.barGridRows,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (id.present) {
      map['id'] = Variable<String>(id.value);
    }
    if (pinRequired.present) {
      map['pin_required'] = Variable<bool>(pinRequired.value);
    }
    if (autoLockEnabled.present) {
      map['auto_lock_enabled'] = Variable<bool>(autoLockEnabled.value);
    }
    if (themeMode.present) {
      map['theme_mode'] = Variable<String>(themeMode.value);
    }
    if (language.present) {
      map['language'] = Variable<String>(language.value);
    }
    if (barGridRows.present) {
      map['bar_grid_rows'] = Variable<int>(barGridRows.value);
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('AppSettingsTableCompanion(')
          ..write('id: $id, ')
          ..write('pinRequired: $pinRequired, ')
          ..write('autoLockEnabled: $autoLockEnabled, ')
          ..write('themeMode: $themeMode, ')
          ..write('language: $language, ')
          ..write('barGridRows: $barGridRows, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $RemoteSyncStateTable extends RemoteSyncState
    with TableInfo<$RemoteSyncStateTable, RemoteSyncStateRow> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $RemoteSyncStateTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _deviceIdMeta = const VerificationMeta(
    'deviceId',
  );
  @override
  late final GeneratedColumn<String> deviceId = GeneratedColumn<String>(
    'device_id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _serverCursorMeta = const VerificationMeta(
    'serverCursor',
  );
  @override
  late final GeneratedColumn<String> serverCursor = GeneratedColumn<String>(
    'server_cursor',
    aliasedName,
    true,
    type: DriftSqlType.string,
    requiredDuringInsert: false,
  );
  static const VerificationMeta _lastSuccessfulSyncAtMeta =
      const VerificationMeta('lastSuccessfulSyncAt');
  @override
  late final GeneratedColumn<DateTime> lastSuccessfulSyncAt =
      GeneratedColumn<DateTime>(
        'last_successful_sync_at',
        aliasedName,
        true,
        type: DriftSqlType.dateTime,
        requiredDuringInsert: false,
      );
  static const VerificationMeta _lastAttemptedSyncAtMeta =
      const VerificationMeta('lastAttemptedSyncAt');
  @override
  late final GeneratedColumn<DateTime> lastAttemptedSyncAt =
      GeneratedColumn<DateTime>(
        'last_attempted_sync_at',
        aliasedName,
        true,
        type: DriftSqlType.dateTime,
        requiredDuringInsert: false,
      );
  static const VerificationMeta _consecutiveFailureCountMeta =
      const VerificationMeta('consecutiveFailureCount');
  @override
  late final GeneratedColumn<int> consecutiveFailureCount =
      GeneratedColumn<int>(
        'consecutive_failure_count',
        aliasedName,
        false,
        type: DriftSqlType.int,
        requiredDuringInsert: false,
        defaultValue: const Constant(0),
      );
  @override
  List<GeneratedColumn> get $columns => [
    deviceId,
    serverCursor,
    lastSuccessfulSyncAt,
    lastAttemptedSyncAt,
    consecutiveFailureCount,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'remote_sync_state';
  @override
  VerificationContext validateIntegrity(
    Insertable<RemoteSyncStateRow> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('device_id')) {
      context.handle(
        _deviceIdMeta,
        deviceId.isAcceptableOrUnknown(data['device_id']!, _deviceIdMeta),
      );
    } else if (isInserting) {
      context.missing(_deviceIdMeta);
    }
    if (data.containsKey('server_cursor')) {
      context.handle(
        _serverCursorMeta,
        serverCursor.isAcceptableOrUnknown(
          data['server_cursor']!,
          _serverCursorMeta,
        ),
      );
    }
    if (data.containsKey('last_successful_sync_at')) {
      context.handle(
        _lastSuccessfulSyncAtMeta,
        lastSuccessfulSyncAt.isAcceptableOrUnknown(
          data['last_successful_sync_at']!,
          _lastSuccessfulSyncAtMeta,
        ),
      );
    }
    if (data.containsKey('last_attempted_sync_at')) {
      context.handle(
        _lastAttemptedSyncAtMeta,
        lastAttemptedSyncAt.isAcceptableOrUnknown(
          data['last_attempted_sync_at']!,
          _lastAttemptedSyncAtMeta,
        ),
      );
    }
    if (data.containsKey('consecutive_failure_count')) {
      context.handle(
        _consecutiveFailureCountMeta,
        consecutiveFailureCount.isAcceptableOrUnknown(
          data['consecutive_failure_count']!,
          _consecutiveFailureCountMeta,
        ),
      );
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {deviceId};
  @override
  RemoteSyncStateRow map(Map<String, dynamic> data, {String? tablePrefix}) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return RemoteSyncStateRow(
      deviceId: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}device_id'],
      )!,
      serverCursor: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}server_cursor'],
      ),
      lastSuccessfulSyncAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}last_successful_sync_at'],
      ),
      lastAttemptedSyncAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}last_attempted_sync_at'],
      ),
      consecutiveFailureCount: attachedDatabase.typeMapping.read(
        DriftSqlType.int,
        data['${effectivePrefix}consecutive_failure_count'],
      )!,
    );
  }

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

class RemoteSyncStateRow extends DataClass
    implements Insertable<RemoteSyncStateRow> {
  final String deviceId;
  final String? serverCursor;
  final DateTime? lastSuccessfulSyncAt;
  final DateTime? lastAttemptedSyncAt;
  final int consecutiveFailureCount;
  const RemoteSyncStateRow({
    required this.deviceId,
    this.serverCursor,
    this.lastSuccessfulSyncAt,
    this.lastAttemptedSyncAt,
    required this.consecutiveFailureCount,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['device_id'] = Variable<String>(deviceId);
    if (!nullToAbsent || serverCursor != null) {
      map['server_cursor'] = Variable<String>(serverCursor);
    }
    if (!nullToAbsent || lastSuccessfulSyncAt != null) {
      map['last_successful_sync_at'] = Variable<DateTime>(lastSuccessfulSyncAt);
    }
    if (!nullToAbsent || lastAttemptedSyncAt != null) {
      map['last_attempted_sync_at'] = Variable<DateTime>(lastAttemptedSyncAt);
    }
    map['consecutive_failure_count'] = Variable<int>(consecutiveFailureCount);
    return map;
  }

  RemoteSyncStateCompanion toCompanion(bool nullToAbsent) {
    return RemoteSyncStateCompanion(
      deviceId: Value(deviceId),
      serverCursor: serverCursor == null && nullToAbsent
          ? const Value.absent()
          : Value(serverCursor),
      lastSuccessfulSyncAt: lastSuccessfulSyncAt == null && nullToAbsent
          ? const Value.absent()
          : Value(lastSuccessfulSyncAt),
      lastAttemptedSyncAt: lastAttemptedSyncAt == null && nullToAbsent
          ? const Value.absent()
          : Value(lastAttemptedSyncAt),
      consecutiveFailureCount: Value(consecutiveFailureCount),
    );
  }

  factory RemoteSyncStateRow.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return RemoteSyncStateRow(
      deviceId: serializer.fromJson<String>(json['deviceId']),
      serverCursor: serializer.fromJson<String?>(json['serverCursor']),
      lastSuccessfulSyncAt: serializer.fromJson<DateTime?>(
        json['lastSuccessfulSyncAt'],
      ),
      lastAttemptedSyncAt: serializer.fromJson<DateTime?>(
        json['lastAttemptedSyncAt'],
      ),
      consecutiveFailureCount: serializer.fromJson<int>(
        json['consecutiveFailureCount'],
      ),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'deviceId': serializer.toJson<String>(deviceId),
      'serverCursor': serializer.toJson<String?>(serverCursor),
      'lastSuccessfulSyncAt': serializer.toJson<DateTime?>(
        lastSuccessfulSyncAt,
      ),
      'lastAttemptedSyncAt': serializer.toJson<DateTime?>(lastAttemptedSyncAt),
      'consecutiveFailureCount': serializer.toJson<int>(
        consecutiveFailureCount,
      ),
    };
  }

  RemoteSyncStateRow copyWith({
    String? deviceId,
    Value<String?> serverCursor = const Value.absent(),
    Value<DateTime?> lastSuccessfulSyncAt = const Value.absent(),
    Value<DateTime?> lastAttemptedSyncAt = const Value.absent(),
    int? consecutiveFailureCount,
  }) => RemoteSyncStateRow(
    deviceId: deviceId ?? this.deviceId,
    serverCursor: serverCursor.present ? serverCursor.value : this.serverCursor,
    lastSuccessfulSyncAt: lastSuccessfulSyncAt.present
        ? lastSuccessfulSyncAt.value
        : this.lastSuccessfulSyncAt,
    lastAttemptedSyncAt: lastAttemptedSyncAt.present
        ? lastAttemptedSyncAt.value
        : this.lastAttemptedSyncAt,
    consecutiveFailureCount:
        consecutiveFailureCount ?? this.consecutiveFailureCount,
  );
  RemoteSyncStateRow copyWithCompanion(RemoteSyncStateCompanion data) {
    return RemoteSyncStateRow(
      deviceId: data.deviceId.present ? data.deviceId.value : this.deviceId,
      serverCursor: data.serverCursor.present
          ? data.serverCursor.value
          : this.serverCursor,
      lastSuccessfulSyncAt: data.lastSuccessfulSyncAt.present
          ? data.lastSuccessfulSyncAt.value
          : this.lastSuccessfulSyncAt,
      lastAttemptedSyncAt: data.lastAttemptedSyncAt.present
          ? data.lastAttemptedSyncAt.value
          : this.lastAttemptedSyncAt,
      consecutiveFailureCount: data.consecutiveFailureCount.present
          ? data.consecutiveFailureCount.value
          : this.consecutiveFailureCount,
    );
  }

  @override
  String toString() {
    return (StringBuffer('RemoteSyncStateRow(')
          ..write('deviceId: $deviceId, ')
          ..write('serverCursor: $serverCursor, ')
          ..write('lastSuccessfulSyncAt: $lastSuccessfulSyncAt, ')
          ..write('lastAttemptedSyncAt: $lastAttemptedSyncAt, ')
          ..write('consecutiveFailureCount: $consecutiveFailureCount')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(
    deviceId,
    serverCursor,
    lastSuccessfulSyncAt,
    lastAttemptedSyncAt,
    consecutiveFailureCount,
  );
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is RemoteSyncStateRow &&
          other.deviceId == this.deviceId &&
          other.serverCursor == this.serverCursor &&
          other.lastSuccessfulSyncAt == this.lastSuccessfulSyncAt &&
          other.lastAttemptedSyncAt == this.lastAttemptedSyncAt &&
          other.consecutiveFailureCount == this.consecutiveFailureCount);
}

class RemoteSyncStateCompanion extends UpdateCompanion<RemoteSyncStateRow> {
  final Value<String> deviceId;
  final Value<String?> serverCursor;
  final Value<DateTime?> lastSuccessfulSyncAt;
  final Value<DateTime?> lastAttemptedSyncAt;
  final Value<int> consecutiveFailureCount;
  final Value<int> rowid;
  const RemoteSyncStateCompanion({
    this.deviceId = const Value.absent(),
    this.serverCursor = const Value.absent(),
    this.lastSuccessfulSyncAt = const Value.absent(),
    this.lastAttemptedSyncAt = const Value.absent(),
    this.consecutiveFailureCount = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  RemoteSyncStateCompanion.insert({
    required String deviceId,
    this.serverCursor = const Value.absent(),
    this.lastSuccessfulSyncAt = const Value.absent(),
    this.lastAttemptedSyncAt = const Value.absent(),
    this.consecutiveFailureCount = const Value.absent(),
    this.rowid = const Value.absent(),
  }) : deviceId = Value(deviceId);
  static Insertable<RemoteSyncStateRow> custom({
    Expression<String>? deviceId,
    Expression<String>? serverCursor,
    Expression<DateTime>? lastSuccessfulSyncAt,
    Expression<DateTime>? lastAttemptedSyncAt,
    Expression<int>? consecutiveFailureCount,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (deviceId != null) 'device_id': deviceId,
      if (serverCursor != null) 'server_cursor': serverCursor,
      if (lastSuccessfulSyncAt != null)
        'last_successful_sync_at': lastSuccessfulSyncAt,
      if (lastAttemptedSyncAt != null)
        'last_attempted_sync_at': lastAttemptedSyncAt,
      if (consecutiveFailureCount != null)
        'consecutive_failure_count': consecutiveFailureCount,
      if (rowid != null) 'rowid': rowid,
    });
  }

  RemoteSyncStateCompanion copyWith({
    Value<String>? deviceId,
    Value<String?>? serverCursor,
    Value<DateTime?>? lastSuccessfulSyncAt,
    Value<DateTime?>? lastAttemptedSyncAt,
    Value<int>? consecutiveFailureCount,
    Value<int>? rowid,
  }) {
    return RemoteSyncStateCompanion(
      deviceId: deviceId ?? this.deviceId,
      serverCursor: serverCursor ?? this.serverCursor,
      lastSuccessfulSyncAt: lastSuccessfulSyncAt ?? this.lastSuccessfulSyncAt,
      lastAttemptedSyncAt: lastAttemptedSyncAt ?? this.lastAttemptedSyncAt,
      consecutiveFailureCount:
          consecutiveFailureCount ?? this.consecutiveFailureCount,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (deviceId.present) {
      map['device_id'] = Variable<String>(deviceId.value);
    }
    if (serverCursor.present) {
      map['server_cursor'] = Variable<String>(serverCursor.value);
    }
    if (lastSuccessfulSyncAt.present) {
      map['last_successful_sync_at'] = Variable<DateTime>(
        lastSuccessfulSyncAt.value,
      );
    }
    if (lastAttemptedSyncAt.present) {
      map['last_attempted_sync_at'] = Variable<DateTime>(
        lastAttemptedSyncAt.value,
      );
    }
    if (consecutiveFailureCount.present) {
      map['consecutive_failure_count'] = Variable<int>(
        consecutiveFailureCount.value,
      );
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('RemoteSyncStateCompanion(')
          ..write('deviceId: $deviceId, ')
          ..write('serverCursor: $serverCursor, ')
          ..write('lastSuccessfulSyncAt: $lastSuccessfulSyncAt, ')
          ..write('lastAttemptedSyncAt: $lastAttemptedSyncAt, ')
          ..write('consecutiveFailureCount: $consecutiveFailureCount, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $ProcessedRemoteCommandsTable extends ProcessedRemoteCommands
    with TableInfo<$ProcessedRemoteCommandsTable, ProcessedRemoteCommandRow> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $ProcessedRemoteCommandsTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _commandIdMeta = const VerificationMeta(
    'commandId',
  );
  @override
  late final GeneratedColumn<String> commandId = GeneratedColumn<String>(
    'command_id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _commandTypeMeta = const VerificationMeta(
    'commandType',
  );
  @override
  late final GeneratedColumn<String> commandType = GeneratedColumn<String>(
    'command_type',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _processedAtMeta = const VerificationMeta(
    'processedAt',
  );
  @override
  late final GeneratedColumn<DateTime> processedAt = GeneratedColumn<DateTime>(
    'processed_at',
    aliasedName,
    false,
    type: DriftSqlType.dateTime,
    requiredDuringInsert: true,
  );
  @override
  late final GeneratedColumnWithTypeConverter<CommandResult, String> result =
      GeneratedColumn<String>(
        'result',
        aliasedName,
        false,
        type: DriftSqlType.string,
        requiredDuringInsert: true,
      ).withConverter<CommandResult>(
        $ProcessedRemoteCommandsTable.$converterresult,
      );
  @override
  List<GeneratedColumn> get $columns => [
    commandId,
    commandType,
    processedAt,
    result,
  ];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'processed_remote_commands';
  @override
  VerificationContext validateIntegrity(
    Insertable<ProcessedRemoteCommandRow> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('command_id')) {
      context.handle(
        _commandIdMeta,
        commandId.isAcceptableOrUnknown(data['command_id']!, _commandIdMeta),
      );
    } else if (isInserting) {
      context.missing(_commandIdMeta);
    }
    if (data.containsKey('command_type')) {
      context.handle(
        _commandTypeMeta,
        commandType.isAcceptableOrUnknown(
          data['command_type']!,
          _commandTypeMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_commandTypeMeta);
    }
    if (data.containsKey('processed_at')) {
      context.handle(
        _processedAtMeta,
        processedAt.isAcceptableOrUnknown(
          data['processed_at']!,
          _processedAtMeta,
        ),
      );
    } else if (isInserting) {
      context.missing(_processedAtMeta);
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {commandId};
  @override
  ProcessedRemoteCommandRow map(
    Map<String, dynamic> data, {
    String? tablePrefix,
  }) {
    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
    return ProcessedRemoteCommandRow(
      commandId: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}command_id'],
      )!,
      commandType: attachedDatabase.typeMapping.read(
        DriftSqlType.string,
        data['${effectivePrefix}command_type'],
      )!,
      processedAt: attachedDatabase.typeMapping.read(
        DriftSqlType.dateTime,
        data['${effectivePrefix}processed_at'],
      )!,
      result: $ProcessedRemoteCommandsTable.$converterresult.fromSql(
        attachedDatabase.typeMapping.read(
          DriftSqlType.string,
          data['${effectivePrefix}result'],
        )!,
      ),
    );
  }

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

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

class ProcessedRemoteCommandRow extends DataClass
    implements Insertable<ProcessedRemoteCommandRow> {
  final String commandId;
  final String commandType;
  final DateTime processedAt;
  final CommandResult result;
  const ProcessedRemoteCommandRow({
    required this.commandId,
    required this.commandType,
    required this.processedAt,
    required this.result,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['command_id'] = Variable<String>(commandId);
    map['command_type'] = Variable<String>(commandType);
    map['processed_at'] = Variable<DateTime>(processedAt);
    {
      map['result'] = Variable<String>(
        $ProcessedRemoteCommandsTable.$converterresult.toSql(result),
      );
    }
    return map;
  }

  ProcessedRemoteCommandsCompanion toCompanion(bool nullToAbsent) {
    return ProcessedRemoteCommandsCompanion(
      commandId: Value(commandId),
      commandType: Value(commandType),
      processedAt: Value(processedAt),
      result: Value(result),
    );
  }

  factory ProcessedRemoteCommandRow.fromJson(
    Map<String, dynamic> json, {
    ValueSerializer? serializer,
  }) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return ProcessedRemoteCommandRow(
      commandId: serializer.fromJson<String>(json['commandId']),
      commandType: serializer.fromJson<String>(json['commandType']),
      processedAt: serializer.fromJson<DateTime>(json['processedAt']),
      result: $ProcessedRemoteCommandsTable.$converterresult.fromJson(
        serializer.fromJson<String>(json['result']),
      ),
    );
  }
  @override
  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
    serializer ??= driftRuntimeOptions.defaultSerializer;
    return <String, dynamic>{
      'commandId': serializer.toJson<String>(commandId),
      'commandType': serializer.toJson<String>(commandType),
      'processedAt': serializer.toJson<DateTime>(processedAt),
      'result': serializer.toJson<String>(
        $ProcessedRemoteCommandsTable.$converterresult.toJson(result),
      ),
    };
  }

  ProcessedRemoteCommandRow copyWith({
    String? commandId,
    String? commandType,
    DateTime? processedAt,
    CommandResult? result,
  }) => ProcessedRemoteCommandRow(
    commandId: commandId ?? this.commandId,
    commandType: commandType ?? this.commandType,
    processedAt: processedAt ?? this.processedAt,
    result: result ?? this.result,
  );
  ProcessedRemoteCommandRow copyWithCompanion(
    ProcessedRemoteCommandsCompanion data,
  ) {
    return ProcessedRemoteCommandRow(
      commandId: data.commandId.present ? data.commandId.value : this.commandId,
      commandType: data.commandType.present
          ? data.commandType.value
          : this.commandType,
      processedAt: data.processedAt.present
          ? data.processedAt.value
          : this.processedAt,
      result: data.result.present ? data.result.value : this.result,
    );
  }

  @override
  String toString() {
    return (StringBuffer('ProcessedRemoteCommandRow(')
          ..write('commandId: $commandId, ')
          ..write('commandType: $commandType, ')
          ..write('processedAt: $processedAt, ')
          ..write('result: $result')
          ..write(')'))
        .toString();
  }

  @override
  int get hashCode => Object.hash(commandId, commandType, processedAt, result);
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is ProcessedRemoteCommandRow &&
          other.commandId == this.commandId &&
          other.commandType == this.commandType &&
          other.processedAt == this.processedAt &&
          other.result == this.result);
}

class ProcessedRemoteCommandsCompanion
    extends UpdateCompanion<ProcessedRemoteCommandRow> {
  final Value<String> commandId;
  final Value<String> commandType;
  final Value<DateTime> processedAt;
  final Value<CommandResult> result;
  final Value<int> rowid;
  const ProcessedRemoteCommandsCompanion({
    this.commandId = const Value.absent(),
    this.commandType = const Value.absent(),
    this.processedAt = const Value.absent(),
    this.result = const Value.absent(),
    this.rowid = const Value.absent(),
  });
  ProcessedRemoteCommandsCompanion.insert({
    required String commandId,
    required String commandType,
    required DateTime processedAt,
    required CommandResult result,
    this.rowid = const Value.absent(),
  }) : commandId = Value(commandId),
       commandType = Value(commandType),
       processedAt = Value(processedAt),
       result = Value(result);
  static Insertable<ProcessedRemoteCommandRow> custom({
    Expression<String>? commandId,
    Expression<String>? commandType,
    Expression<DateTime>? processedAt,
    Expression<String>? result,
    Expression<int>? rowid,
  }) {
    return RawValuesInsertable({
      if (commandId != null) 'command_id': commandId,
      if (commandType != null) 'command_type': commandType,
      if (processedAt != null) 'processed_at': processedAt,
      if (result != null) 'result': result,
      if (rowid != null) 'rowid': rowid,
    });
  }

  ProcessedRemoteCommandsCompanion copyWith({
    Value<String>? commandId,
    Value<String>? commandType,
    Value<DateTime>? processedAt,
    Value<CommandResult>? result,
    Value<int>? rowid,
  }) {
    return ProcessedRemoteCommandsCompanion(
      commandId: commandId ?? this.commandId,
      commandType: commandType ?? this.commandType,
      processedAt: processedAt ?? this.processedAt,
      result: result ?? this.result,
      rowid: rowid ?? this.rowid,
    );
  }

  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (commandId.present) {
      map['command_id'] = Variable<String>(commandId.value);
    }
    if (commandType.present) {
      map['command_type'] = Variable<String>(commandType.value);
    }
    if (processedAt.present) {
      map['processed_at'] = Variable<DateTime>(processedAt.value);
    }
    if (result.present) {
      map['result'] = Variable<String>(
        $ProcessedRemoteCommandsTable.$converterresult.toSql(result.value),
      );
    }
    if (rowid.present) {
      map['rowid'] = Variable<int>(rowid.value);
    }
    return map;
  }

  @override
  String toString() {
    return (StringBuffer('ProcessedRemoteCommandsCompanion(')
          ..write('commandId: $commandId, ')
          ..write('commandType: $commandType, ')
          ..write('processedAt: $processedAt, ')
          ..write('result: $result, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

class $TabEventsTable extends TabEvents
    with TableInfo<$TabEventsTable, TabEventRow> {
  @override
  final GeneratedDatabase attachedDatabase;
  final String? _alias;
  $TabEventsTable(this.attachedDatabase, [this._alias]);
  static const VerificationMeta _idMeta = const VerificationMeta('id');
  @override
  late final GeneratedColumn<String> id = GeneratedColumn<String>(
    'id',
    aliasedName,
    false,
    type: DriftSqlType.string,
    requiredDuringInsert: true,
  );
  static const VerificationMeta _payloadMeta = const VerificationMeta(
    'payload',
  );
  @override
  late final GeneratedColumn<String> payload = GeneratedColumn<String>(
    'payload',
    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: true,
  );
  @override
  List<GeneratedColumn> get $columns => [id, payload, createdAt];
  @override
  String get aliasedName => _alias ?? actualTableName;
  @override
  String get actualTableName => $name;
  static const String $name = 'tab_events';
  @override
  VerificationContext validateIntegrity(
    Insertable<TabEventRow> instance, {
    bool isInserting = false,
  }) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('id')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
    } else if (isInserting) {
      context.missing(_idMeta);
    }
    if (data.containsKey('payload')) {
      context.handle(
        _payloadMeta,
        payload.isAcceptableOrUnknown(data['payload']!, _payloadMeta),
      );
    } else if (isInserting) {
      context.missing(_payloadMeta);
    }
    if (data.containsKey('created_at')) {
      context.handle(
        _createdAtMeta,
        createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta),
      );
    } else if (isInserting) {
      context.missing(_createdAtMeta);
    }
    return context;
  }

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

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

class TabEventRow extends DataClass implements Insertable<TabEventRow> {
  /// The event's UUID.
  final String id;

  /// The event as JSON, exactly as it is sent.
  final String payload;
  final DateTime createdAt;
  const TabEventRow({
    required this.id,
    required this.payload,
    required this.createdAt,
  });
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    map['id'] = Variable<String>(id);
    map['payload'] = Variable<String>(payload);
    map['created_at'] = Variable<DateTime>(createdAt);
    return map;
  }

  TabEventsCompanion toCompanion(bool nullToAbsent) {
    return TabEventsCompanion(
      id: Value(id),
      payload: Value(payload),
      createdAt: Value(createdAt),
    );
  }

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

  TabEventRow copyWith({String? id, String? payload, DateTime? createdAt}) =>
      TabEventRow(
        id: id ?? this.id,
        payload: payload ?? this.payload,
        createdAt: createdAt ?? this.createdAt,
      );
  TabEventRow copyWithCompanion(TabEventsCompanion data) {
    return TabEventRow(
      id: data.id.present ? data.id.value : this.id,
      payload: data.payload.present ? data.payload.value : this.payload,
      createdAt: data.createdAt.present ? data.createdAt.value : this.createdAt,
    );
  }

  @override
  String toString() {
    return (StringBuffer('TabEventRow(')
          ..write('id: $id, ')
          ..write('payload: $payload, ')
          ..write('createdAt: $createdAt')
          ..write(')'))
        .toString();
  }

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

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

  TabEventsCompanion copyWith({
    Value<String>? id,
    Value<String>? payload,
    Value<DateTime>? createdAt,
    Value<int>? rowid,
  }) {
    return TabEventsCompanion(
      id: id ?? this.id,
      payload: payload ?? this.payload,
      createdAt: createdAt ?? this.createdAt,
      rowid: rowid ?? this.rowid,
    );
  }

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

  @override
  String toString() {
    return (StringBuffer('TabEventsCompanion(')
          ..write('id: $id, ')
          ..write('payload: $payload, ')
          ..write('createdAt: $createdAt, ')
          ..write('rowid: $rowid')
          ..write(')'))
        .toString();
  }
}

abstract class _$AppDatabase extends GeneratedDatabase {
  _$AppDatabase(QueryExecutor e) : super(e);
  $AppDatabaseManager get managers => $AppDatabaseManager(this);
  late final $ProductsTable products = $ProductsTable(this);
  late final $BarTabsTable barTabs = $BarTabsTable(this);
  late final $TabItemsTable tabItems = $TabItemsTable(this);
  late final $TabItemPurchasesTable tabItemPurchases = $TabItemPurchasesTable(
    this,
  );
  late final $ClosedTabsTable closedTabs = $ClosedTabsTable(this);
  late final $ClosedTabItemsTable closedTabItems = $ClosedTabItemsTable(this);
  late final $AppSettingsTableTable appSettingsTable = $AppSettingsTableTable(
    this,
  );
  late final $RemoteSyncStateTable remoteSyncState = $RemoteSyncStateTable(
    this,
  );
  late final $ProcessedRemoteCommandsTable processedRemoteCommands =
      $ProcessedRemoteCommandsTable(this);
  late final $TabEventsTable tabEvents = $TabEventsTable(this);
  @override
  Iterable<TableInfo<Table, Object?>> get allTables =>
      allSchemaEntities.whereType<TableInfo<Table, Object?>>();
  @override
  List<DatabaseSchemaEntity> get allSchemaEntities => [
    products,
    barTabs,
    tabItems,
    tabItemPurchases,
    closedTabs,
    closedTabItems,
    appSettingsTable,
    remoteSyncState,
    processedRemoteCommands,
    tabEvents,
  ];
  @override
  StreamQueryUpdateRules get streamUpdateRules => const StreamQueryUpdateRules([
    WritePropagation(
      on: TableUpdateQuery.onTableName(
        'bar_tabs',
        limitUpdateKind: UpdateKind.delete,
      ),
      result: [TableUpdate('tab_items', kind: UpdateKind.delete)],
    ),
    WritePropagation(
      on: TableUpdateQuery.onTableName(
        'tab_items',
        limitUpdateKind: UpdateKind.delete,
      ),
      result: [TableUpdate('tab_item_purchases', kind: UpdateKind.delete)],
    ),
  ]);
}

typedef $$ProductsTableCreateCompanionBuilder =
    ProductsCompanion Function({
      required String id,
      required String name,
      required String category,
      required int stockQuantity,
      required int lowStockThreshold,
      Value<bool> infiniteStock,
      required int priceInCents,
      Value<String?> imagePath,
      Value<bool> active,
      Value<int> rowid,
    });
typedef $$ProductsTableUpdateCompanionBuilder =
    ProductsCompanion Function({
      Value<String> id,
      Value<String> name,
      Value<String> category,
      Value<int> stockQuantity,
      Value<int> lowStockThreshold,
      Value<bool> infiniteStock,
      Value<int> priceInCents,
      Value<String?> imagePath,
      Value<bool> active,
      Value<int> rowid,
    });

final class $$ProductsTableReferences
    extends BaseReferences<_$AppDatabase, $ProductsTable, ProductRow> {
  $$ProductsTableReferences(super.$_db, super.$_table, super.$_typedResult);

  static MultiTypedResultKey<$TabItemsTable, List<TabItemRow>>
  _tabItemsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
    db.tabItems,
    aliasName: 'products__id__tab_items__product_id',
  );

  $$TabItemsTableProcessedTableManager get tabItemsRefs {
    final manager = $$TabItemsTableTableManager(
      $_db,
      $_db.tabItems,
    ).filter((f) => f.productId.id.sqlEquals($_itemColumn<String>('id')!));

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

class $$ProductsTableFilterComposer
    extends Composer<_$AppDatabase, $ProductsTable> {
  $$ProductsTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnFilters(column),
  );

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

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

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

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

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

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

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

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

  Expression<bool> tabItemsRefs(
    Expression<bool> Function($$TabItemsTableFilterComposer f) f,
  ) {
    final $$TabItemsTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.id,
      referencedTable: $db.tabItems,
      getReferencedColumn: (t) => t.productId,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$TabItemsTableFilterComposer(
            $db: $db,
            $table: $db.tabItems,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $$ProductsTableOrderingComposer
    extends Composer<_$AppDatabase, $ProductsTable> {
  $$ProductsTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

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

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

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

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

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

class $$ProductsTableAnnotationComposer
    extends Composer<_$AppDatabase, $ProductsTable> {
  $$ProductsTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get id =>
      $composableBuilder(column: $table.id, builder: (column) => column);

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

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

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

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

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

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

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

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

  Expression<T> tabItemsRefs<T extends Object>(
    Expression<T> Function($$TabItemsTableAnnotationComposer a) f,
  ) {
    final $$TabItemsTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.id,
      referencedTable: $db.tabItems,
      getReferencedColumn: (t) => t.productId,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$TabItemsTableAnnotationComposer(
            $db: $db,
            $table: $db.tabItems,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $$ProductsTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $ProductsTable,
          ProductRow,
          $$ProductsTableFilterComposer,
          $$ProductsTableOrderingComposer,
          $$ProductsTableAnnotationComposer,
          $$ProductsTableCreateCompanionBuilder,
          $$ProductsTableUpdateCompanionBuilder,
          (ProductRow, $$ProductsTableReferences),
          ProductRow,
          PrefetchHooks Function({bool tabItemsRefs})
        > {
  $$ProductsTableTableManager(_$AppDatabase db, $ProductsTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$ProductsTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$ProductsTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$ProductsTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> id = const Value.absent(),
                Value<String> name = const Value.absent(),
                Value<String> category = const Value.absent(),
                Value<int> stockQuantity = const Value.absent(),
                Value<int> lowStockThreshold = const Value.absent(),
                Value<bool> infiniteStock = const Value.absent(),
                Value<int> priceInCents = const Value.absent(),
                Value<String?> imagePath = const Value.absent(),
                Value<bool> active = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => ProductsCompanion(
                id: id,
                name: name,
                category: category,
                stockQuantity: stockQuantity,
                lowStockThreshold: lowStockThreshold,
                infiniteStock: infiniteStock,
                priceInCents: priceInCents,
                imagePath: imagePath,
                active: active,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String id,
                required String name,
                required String category,
                required int stockQuantity,
                required int lowStockThreshold,
                Value<bool> infiniteStock = const Value.absent(),
                required int priceInCents,
                Value<String?> imagePath = const Value.absent(),
                Value<bool> active = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => ProductsCompanion.insert(
                id: id,
                name: name,
                category: category,
                stockQuantity: stockQuantity,
                lowStockThreshold: lowStockThreshold,
                infiniteStock: infiniteStock,
                priceInCents: priceInCents,
                imagePath: imagePath,
                active: active,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map(
                (e) => (
                  e.readTable(table),
                  $$ProductsTableReferences(db, table, e),
                ),
              )
              .toList(),
          prefetchHooksCallback: ({tabItemsRefs = false}) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [if (tabItemsRefs) db.tabItems],
              addJoins: null,
              getPrefetchedDataCallback: (items) async {
                return [
                  if (tabItemsRefs)
                    await $_getPrefetchedData<
                      ProductRow,
                      $ProductsTable,
                      TabItemRow
                    >(
                      currentTable: table,
                      referencedTable: $$ProductsTableReferences
                          ._tabItemsRefsTable(db),
                      managerFromTypedResult: (p0) =>
                          $$ProductsTableReferences(db, table, p0).tabItemsRefs,
                      referencedItemsForCurrentItem: (item, referencedItems) =>
                          referencedItems.where((e) => e.productId == item.id),
                      typedResults: items,
                    ),
                ];
              },
            );
          },
        ),
      );
}

typedef $$ProductsTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $ProductsTable,
      ProductRow,
      $$ProductsTableFilterComposer,
      $$ProductsTableOrderingComposer,
      $$ProductsTableAnnotationComposer,
      $$ProductsTableCreateCompanionBuilder,
      $$ProductsTableUpdateCompanionBuilder,
      (ProductRow, $$ProductsTableReferences),
      ProductRow,
      PrefetchHooks Function({bool tabItemsRefs})
    >;
typedef $$BarTabsTableCreateCompanionBuilder =
    BarTabsCompanion Function({
      required String id,
      required String customerName,
      required DateTime openedAt,
      Value<int> version,
      Value<int> rowid,
    });
typedef $$BarTabsTableUpdateCompanionBuilder =
    BarTabsCompanion Function({
      Value<String> id,
      Value<String> customerName,
      Value<DateTime> openedAt,
      Value<int> version,
      Value<int> rowid,
    });

final class $$BarTabsTableReferences
    extends BaseReferences<_$AppDatabase, $BarTabsTable, BarTabRow> {
  $$BarTabsTableReferences(super.$_db, super.$_table, super.$_typedResult);

  static MultiTypedResultKey<$TabItemsTable, List<TabItemRow>>
  _tabItemsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
    db.tabItems,
    aliasName: 'bar_tabs__id__tab_items__tab_id',
  );

  $$TabItemsTableProcessedTableManager get tabItemsRefs {
    final manager = $$TabItemsTableTableManager(
      $_db,
      $_db.tabItems,
    ).filter((f) => f.tabId.id.sqlEquals($_itemColumn<String>('id')!));

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

class $$BarTabsTableFilterComposer
    extends Composer<_$AppDatabase, $BarTabsTable> {
  $$BarTabsTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnFilters(column),
  );

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

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

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

  Expression<bool> tabItemsRefs(
    Expression<bool> Function($$TabItemsTableFilterComposer f) f,
  ) {
    final $$TabItemsTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.id,
      referencedTable: $db.tabItems,
      getReferencedColumn: (t) => t.tabId,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$TabItemsTableFilterComposer(
            $db: $db,
            $table: $db.tabItems,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $$BarTabsTableOrderingComposer
    extends Composer<_$AppDatabase, $BarTabsTable> {
  $$BarTabsTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

class $$BarTabsTableAnnotationComposer
    extends Composer<_$AppDatabase, $BarTabsTable> {
  $$BarTabsTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get id =>
      $composableBuilder(column: $table.id, builder: (column) => column);

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

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

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

  Expression<T> tabItemsRefs<T extends Object>(
    Expression<T> Function($$TabItemsTableAnnotationComposer a) f,
  ) {
    final $$TabItemsTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.id,
      referencedTable: $db.tabItems,
      getReferencedColumn: (t) => t.tabId,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$TabItemsTableAnnotationComposer(
            $db: $db,
            $table: $db.tabItems,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $$BarTabsTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $BarTabsTable,
          BarTabRow,
          $$BarTabsTableFilterComposer,
          $$BarTabsTableOrderingComposer,
          $$BarTabsTableAnnotationComposer,
          $$BarTabsTableCreateCompanionBuilder,
          $$BarTabsTableUpdateCompanionBuilder,
          (BarTabRow, $$BarTabsTableReferences),
          BarTabRow,
          PrefetchHooks Function({bool tabItemsRefs})
        > {
  $$BarTabsTableTableManager(_$AppDatabase db, $BarTabsTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$BarTabsTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$BarTabsTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$BarTabsTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> id = const Value.absent(),
                Value<String> customerName = const Value.absent(),
                Value<DateTime> openedAt = const Value.absent(),
                Value<int> version = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => BarTabsCompanion(
                id: id,
                customerName: customerName,
                openedAt: openedAt,
                version: version,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String id,
                required String customerName,
                required DateTime openedAt,
                Value<int> version = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => BarTabsCompanion.insert(
                id: id,
                customerName: customerName,
                openedAt: openedAt,
                version: version,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map(
                (e) => (
                  e.readTable(table),
                  $$BarTabsTableReferences(db, table, e),
                ),
              )
              .toList(),
          prefetchHooksCallback: ({tabItemsRefs = false}) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [if (tabItemsRefs) db.tabItems],
              addJoins: null,
              getPrefetchedDataCallback: (items) async {
                return [
                  if (tabItemsRefs)
                    await $_getPrefetchedData<
                      BarTabRow,
                      $BarTabsTable,
                      TabItemRow
                    >(
                      currentTable: table,
                      referencedTable: $$BarTabsTableReferences
                          ._tabItemsRefsTable(db),
                      managerFromTypedResult: (p0) =>
                          $$BarTabsTableReferences(db, table, p0).tabItemsRefs,
                      referencedItemsForCurrentItem: (item, referencedItems) =>
                          referencedItems.where((e) => e.tabId == item.id),
                      typedResults: items,
                    ),
                ];
              },
            );
          },
        ),
      );
}

typedef $$BarTabsTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $BarTabsTable,
      BarTabRow,
      $$BarTabsTableFilterComposer,
      $$BarTabsTableOrderingComposer,
      $$BarTabsTableAnnotationComposer,
      $$BarTabsTableCreateCompanionBuilder,
      $$BarTabsTableUpdateCompanionBuilder,
      (BarTabRow, $$BarTabsTableReferences),
      BarTabRow,
      PrefetchHooks Function({bool tabItemsRefs})
    >;
typedef $$TabItemsTableCreateCompanionBuilder =
    TabItemsCompanion Function({
      required String id,
      required String tabId,
      required String productId,
      required String productName,
      required int quantity,
      required int unitPriceInCents,
      required DateTime createdAt,
      Value<int> rowid,
    });
typedef $$TabItemsTableUpdateCompanionBuilder =
    TabItemsCompanion Function({
      Value<String> id,
      Value<String> tabId,
      Value<String> productId,
      Value<String> productName,
      Value<int> quantity,
      Value<int> unitPriceInCents,
      Value<DateTime> createdAt,
      Value<int> rowid,
    });

final class $$TabItemsTableReferences
    extends BaseReferences<_$AppDatabase, $TabItemsTable, TabItemRow> {
  $$TabItemsTableReferences(super.$_db, super.$_table, super.$_typedResult);

  static $BarTabsTable _tabIdTable(_$AppDatabase db) =>
      db.barTabs.createAlias('tab_items__tab_id__bar_tabs__id');

  $$BarTabsTableProcessedTableManager get tabId {
    final $_column = $_itemColumn<String>('tab_id')!;

    final manager = $$BarTabsTableTableManager(
      $_db,
      $_db.barTabs,
    ).filter((f) => f.id.sqlEquals($_column));
    final item = $_typedResult.readTableOrNull(_tabIdTable($_db));
    if (item == null) return manager;
    return ProcessedTableManager(
      manager.$state.copyWith(prefetchedData: [item]),
    );
  }

  static $ProductsTable _productIdTable(_$AppDatabase db) =>
      db.products.createAlias('tab_items__product_id__products__id');

  $$ProductsTableProcessedTableManager get productId {
    final $_column = $_itemColumn<String>('product_id')!;

    final manager = $$ProductsTableTableManager(
      $_db,
      $_db.products,
    ).filter((f) => f.id.sqlEquals($_column));
    final item = $_typedResult.readTableOrNull(_productIdTable($_db));
    if (item == null) return manager;
    return ProcessedTableManager(
      manager.$state.copyWith(prefetchedData: [item]),
    );
  }

  static MultiTypedResultKey<$TabItemPurchasesTable, List<TabItemPurchaseRow>>
  _tabItemPurchasesRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
    db.tabItemPurchases,
    aliasName: 'tab_items__id__tab_item_purchases__tab_item_id',
  );

  $$TabItemPurchasesTableProcessedTableManager get tabItemPurchasesRefs {
    final manager = $$TabItemPurchasesTableTableManager(
      $_db,
      $_db.tabItemPurchases,
    ).filter((f) => f.tabItemId.id.sqlEquals($_itemColumn<String>('id')!));

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

class $$TabItemsTableFilterComposer
    extends Composer<_$AppDatabase, $TabItemsTable> {
  $$TabItemsTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnFilters(column),
  );

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

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

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

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

  $$BarTabsTableFilterComposer get tabId {
    final $$BarTabsTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.tabId,
      referencedTable: $db.barTabs,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$BarTabsTableFilterComposer(
            $db: $db,
            $table: $db.barTabs,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }

  $$ProductsTableFilterComposer get productId {
    final $$ProductsTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.productId,
      referencedTable: $db.products,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$ProductsTableFilterComposer(
            $db: $db,
            $table: $db.products,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }

  Expression<bool> tabItemPurchasesRefs(
    Expression<bool> Function($$TabItemPurchasesTableFilterComposer f) f,
  ) {
    final $$TabItemPurchasesTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.id,
      referencedTable: $db.tabItemPurchases,
      getReferencedColumn: (t) => t.tabItemId,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$TabItemPurchasesTableFilterComposer(
            $db: $db,
            $table: $db.tabItemPurchases,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $$TabItemsTableOrderingComposer
    extends Composer<_$AppDatabase, $TabItemsTable> {
  $$TabItemsTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

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

  $$BarTabsTableOrderingComposer get tabId {
    final $$BarTabsTableOrderingComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.tabId,
      referencedTable: $db.barTabs,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$BarTabsTableOrderingComposer(
            $db: $db,
            $table: $db.barTabs,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }

  $$ProductsTableOrderingComposer get productId {
    final $$ProductsTableOrderingComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.productId,
      referencedTable: $db.products,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$ProductsTableOrderingComposer(
            $db: $db,
            $table: $db.products,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }
}

class $$TabItemsTableAnnotationComposer
    extends Composer<_$AppDatabase, $TabItemsTable> {
  $$TabItemsTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get id =>
      $composableBuilder(column: $table.id, builder: (column) => column);

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

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

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

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

  $$BarTabsTableAnnotationComposer get tabId {
    final $$BarTabsTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.tabId,
      referencedTable: $db.barTabs,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$BarTabsTableAnnotationComposer(
            $db: $db,
            $table: $db.barTabs,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }

  $$ProductsTableAnnotationComposer get productId {
    final $$ProductsTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.productId,
      referencedTable: $db.products,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$ProductsTableAnnotationComposer(
            $db: $db,
            $table: $db.products,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }

  Expression<T> tabItemPurchasesRefs<T extends Object>(
    Expression<T> Function($$TabItemPurchasesTableAnnotationComposer a) f,
  ) {
    final $$TabItemPurchasesTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.id,
      referencedTable: $db.tabItemPurchases,
      getReferencedColumn: (t) => t.tabItemId,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$TabItemPurchasesTableAnnotationComposer(
            $db: $db,
            $table: $db.tabItemPurchases,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return f(composer);
  }
}

class $$TabItemsTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $TabItemsTable,
          TabItemRow,
          $$TabItemsTableFilterComposer,
          $$TabItemsTableOrderingComposer,
          $$TabItemsTableAnnotationComposer,
          $$TabItemsTableCreateCompanionBuilder,
          $$TabItemsTableUpdateCompanionBuilder,
          (TabItemRow, $$TabItemsTableReferences),
          TabItemRow,
          PrefetchHooks Function({
            bool tabId,
            bool productId,
            bool tabItemPurchasesRefs,
          })
        > {
  $$TabItemsTableTableManager(_$AppDatabase db, $TabItemsTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$TabItemsTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$TabItemsTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$TabItemsTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> id = const Value.absent(),
                Value<String> tabId = const Value.absent(),
                Value<String> productId = const Value.absent(),
                Value<String> productName = const Value.absent(),
                Value<int> quantity = const Value.absent(),
                Value<int> unitPriceInCents = const Value.absent(),
                Value<DateTime> createdAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => TabItemsCompanion(
                id: id,
                tabId: tabId,
                productId: productId,
                productName: productName,
                quantity: quantity,
                unitPriceInCents: unitPriceInCents,
                createdAt: createdAt,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String id,
                required String tabId,
                required String productId,
                required String productName,
                required int quantity,
                required int unitPriceInCents,
                required DateTime createdAt,
                Value<int> rowid = const Value.absent(),
              }) => TabItemsCompanion.insert(
                id: id,
                tabId: tabId,
                productId: productId,
                productName: productName,
                quantity: quantity,
                unitPriceInCents: unitPriceInCents,
                createdAt: createdAt,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map(
                (e) => (
                  e.readTable(table),
                  $$TabItemsTableReferences(db, table, e),
                ),
              )
              .toList(),
          prefetchHooksCallback:
              ({
                tabId = false,
                productId = false,
                tabItemPurchasesRefs = false,
              }) {
                return PrefetchHooks(
                  db: db,
                  explicitlyWatchedTables: [
                    if (tabItemPurchasesRefs) db.tabItemPurchases,
                  ],
                  addJoins:
                      <
                        T extends TableManagerState<
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic,
                          dynamic
                        >
                      >(state) {
                        if (tabId) {
                          state =
                              state.withJoin(
                                    currentTable: table,
                                    currentColumn: table.tabId,
                                    referencedTable: $$TabItemsTableReferences
                                        ._tabIdTable(db),
                                    referencedColumn: $$TabItemsTableReferences
                                        ._tabIdTable(db)
                                        .id,
                                  )
                                  as T;
                        }
                        if (productId) {
                          state =
                              state.withJoin(
                                    currentTable: table,
                                    currentColumn: table.productId,
                                    referencedTable: $$TabItemsTableReferences
                                        ._productIdTable(db),
                                    referencedColumn: $$TabItemsTableReferences
                                        ._productIdTable(db)
                                        .id,
                                  )
                                  as T;
                        }

                        return state;
                      },
                  getPrefetchedDataCallback: (items) async {
                    return [
                      if (tabItemPurchasesRefs)
                        await $_getPrefetchedData<
                          TabItemRow,
                          $TabItemsTable,
                          TabItemPurchaseRow
                        >(
                          currentTable: table,
                          referencedTable: $$TabItemsTableReferences
                              ._tabItemPurchasesRefsTable(db),
                          managerFromTypedResult: (p0) =>
                              $$TabItemsTableReferences(
                                db,
                                table,
                                p0,
                              ).tabItemPurchasesRefs,
                          referencedItemsForCurrentItem:
                              (item, referencedItems) => referencedItems.where(
                                (e) => e.tabItemId == item.id,
                              ),
                          typedResults: items,
                        ),
                    ];
                  },
                );
              },
        ),
      );
}

typedef $$TabItemsTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $TabItemsTable,
      TabItemRow,
      $$TabItemsTableFilterComposer,
      $$TabItemsTableOrderingComposer,
      $$TabItemsTableAnnotationComposer,
      $$TabItemsTableCreateCompanionBuilder,
      $$TabItemsTableUpdateCompanionBuilder,
      (TabItemRow, $$TabItemsTableReferences),
      TabItemRow,
      PrefetchHooks Function({
        bool tabId,
        bool productId,
        bool tabItemPurchasesRefs,
      })
    >;
typedef $$TabItemPurchasesTableCreateCompanionBuilder =
    TabItemPurchasesCompanion Function({
      required String id,
      required String tabItemId,
      required DateTime purchasedAt,
      Value<DateTime?> removedAt,
      Value<int> rowid,
    });
typedef $$TabItemPurchasesTableUpdateCompanionBuilder =
    TabItemPurchasesCompanion Function({
      Value<String> id,
      Value<String> tabItemId,
      Value<DateTime> purchasedAt,
      Value<DateTime?> removedAt,
      Value<int> rowid,
    });

final class $$TabItemPurchasesTableReferences
    extends
        BaseReferences<
          _$AppDatabase,
          $TabItemPurchasesTable,
          TabItemPurchaseRow
        > {
  $$TabItemPurchasesTableReferences(
    super.$_db,
    super.$_table,
    super.$_typedResult,
  );

  static $TabItemsTable _tabItemIdTable(_$AppDatabase db) =>
      db.tabItems.createAlias('tab_item_purchases__tab_item_id__tab_items__id');

  $$TabItemsTableProcessedTableManager get tabItemId {
    final $_column = $_itemColumn<String>('tab_item_id')!;

    final manager = $$TabItemsTableTableManager(
      $_db,
      $_db.tabItems,
    ).filter((f) => f.id.sqlEquals($_column));
    final item = $_typedResult.readTableOrNull(_tabItemIdTable($_db));
    if (item == null) return manager;
    return ProcessedTableManager(
      manager.$state.copyWith(prefetchedData: [item]),
    );
  }
}

class $$TabItemPurchasesTableFilterComposer
    extends Composer<_$AppDatabase, $TabItemPurchasesTable> {
  $$TabItemPurchasesTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnFilters(column),
  );

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

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

  $$TabItemsTableFilterComposer get tabItemId {
    final $$TabItemsTableFilterComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.tabItemId,
      referencedTable: $db.tabItems,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$TabItemsTableFilterComposer(
            $db: $db,
            $table: $db.tabItems,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }
}

class $$TabItemPurchasesTableOrderingComposer
    extends Composer<_$AppDatabase, $TabItemPurchasesTable> {
  $$TabItemPurchasesTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnOrderings(column),
  );

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

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

  $$TabItemsTableOrderingComposer get tabItemId {
    final $$TabItemsTableOrderingComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.tabItemId,
      referencedTable: $db.tabItems,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$TabItemsTableOrderingComposer(
            $db: $db,
            $table: $db.tabItems,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }
}

class $$TabItemPurchasesTableAnnotationComposer
    extends Composer<_$AppDatabase, $TabItemPurchasesTable> {
  $$TabItemPurchasesTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get id =>
      $composableBuilder(column: $table.id, builder: (column) => column);

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

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

  $$TabItemsTableAnnotationComposer get tabItemId {
    final $$TabItemsTableAnnotationComposer composer = $composerBuilder(
      composer: this,
      getCurrentColumn: (t) => t.tabItemId,
      referencedTable: $db.tabItems,
      getReferencedColumn: (t) => t.id,
      builder:
          (
            joinBuilder, {
            $addJoinBuilderToRootComposer,
            $removeJoinBuilderFromRootComposer,
          }) => $$TabItemsTableAnnotationComposer(
            $db: $db,
            $table: $db.tabItems,
            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
            joinBuilder: joinBuilder,
            $removeJoinBuilderFromRootComposer:
                $removeJoinBuilderFromRootComposer,
          ),
    );
    return composer;
  }
}

class $$TabItemPurchasesTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $TabItemPurchasesTable,
          TabItemPurchaseRow,
          $$TabItemPurchasesTableFilterComposer,
          $$TabItemPurchasesTableOrderingComposer,
          $$TabItemPurchasesTableAnnotationComposer,
          $$TabItemPurchasesTableCreateCompanionBuilder,
          $$TabItemPurchasesTableUpdateCompanionBuilder,
          (TabItemPurchaseRow, $$TabItemPurchasesTableReferences),
          TabItemPurchaseRow,
          PrefetchHooks Function({bool tabItemId})
        > {
  $$TabItemPurchasesTableTableManager(
    _$AppDatabase db,
    $TabItemPurchasesTable table,
  ) : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$TabItemPurchasesTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$TabItemPurchasesTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$TabItemPurchasesTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> id = const Value.absent(),
                Value<String> tabItemId = const Value.absent(),
                Value<DateTime> purchasedAt = const Value.absent(),
                Value<DateTime?> removedAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => TabItemPurchasesCompanion(
                id: id,
                tabItemId: tabItemId,
                purchasedAt: purchasedAt,
                removedAt: removedAt,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String id,
                required String tabItemId,
                required DateTime purchasedAt,
                Value<DateTime?> removedAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => TabItemPurchasesCompanion.insert(
                id: id,
                tabItemId: tabItemId,
                purchasedAt: purchasedAt,
                removedAt: removedAt,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map(
                (e) => (
                  e.readTable(table),
                  $$TabItemPurchasesTableReferences(db, table, e),
                ),
              )
              .toList(),
          prefetchHooksCallback: ({tabItemId = false}) {
            return PrefetchHooks(
              db: db,
              explicitlyWatchedTables: [],
              addJoins:
                  <
                    T extends TableManagerState<
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic,
                      dynamic
                    >
                  >(state) {
                    if (tabItemId) {
                      state =
                          state.withJoin(
                                currentTable: table,
                                currentColumn: table.tabItemId,
                                referencedTable:
                                    $$TabItemPurchasesTableReferences
                                        ._tabItemIdTable(db),
                                referencedColumn:
                                    $$TabItemPurchasesTableReferences
                                        ._tabItemIdTable(db)
                                        .id,
                              )
                              as T;
                    }

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

typedef $$TabItemPurchasesTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $TabItemPurchasesTable,
      TabItemPurchaseRow,
      $$TabItemPurchasesTableFilterComposer,
      $$TabItemPurchasesTableOrderingComposer,
      $$TabItemPurchasesTableAnnotationComposer,
      $$TabItemPurchasesTableCreateCompanionBuilder,
      $$TabItemPurchasesTableUpdateCompanionBuilder,
      (TabItemPurchaseRow, $$TabItemPurchasesTableReferences),
      TabItemPurchaseRow,
      PrefetchHooks Function({bool tabItemId})
    >;
typedef $$ClosedTabsTableCreateCompanionBuilder =
    ClosedTabsCompanion Function({
      required String id,
      required String originalTabId,
      required String customerName,
      required DateTime closedAt,
      Value<PaymentMethod> paymentMethod,
      Value<int> rowid,
    });
typedef $$ClosedTabsTableUpdateCompanionBuilder =
    ClosedTabsCompanion Function({
      Value<String> id,
      Value<String> originalTabId,
      Value<String> customerName,
      Value<DateTime> closedAt,
      Value<PaymentMethod> paymentMethod,
      Value<int> rowid,
    });

class $$ClosedTabsTableFilterComposer
    extends Composer<_$AppDatabase, $ClosedTabsTable> {
  $$ClosedTabsTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnFilters(column),
  );

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

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

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

  ColumnWithTypeConverterFilters<PaymentMethod, PaymentMethod, String>
  get paymentMethod => $composableBuilder(
    column: $table.paymentMethod,
    builder: (column) => ColumnWithTypeConverterFilters(column),
  );
}

class $$ClosedTabsTableOrderingComposer
    extends Composer<_$AppDatabase, $ClosedTabsTable> {
  $$ClosedTabsTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

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

class $$ClosedTabsTableAnnotationComposer
    extends Composer<_$AppDatabase, $ClosedTabsTable> {
  $$ClosedTabsTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get id =>
      $composableBuilder(column: $table.id, builder: (column) => column);

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

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

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

  GeneratedColumnWithTypeConverter<PaymentMethod, String> get paymentMethod =>
      $composableBuilder(
        column: $table.paymentMethod,
        builder: (column) => column,
      );
}

class $$ClosedTabsTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $ClosedTabsTable,
          ClosedTabsRow,
          $$ClosedTabsTableFilterComposer,
          $$ClosedTabsTableOrderingComposer,
          $$ClosedTabsTableAnnotationComposer,
          $$ClosedTabsTableCreateCompanionBuilder,
          $$ClosedTabsTableUpdateCompanionBuilder,
          (
            ClosedTabsRow,
            BaseReferences<_$AppDatabase, $ClosedTabsTable, ClosedTabsRow>,
          ),
          ClosedTabsRow,
          PrefetchHooks Function()
        > {
  $$ClosedTabsTableTableManager(_$AppDatabase db, $ClosedTabsTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$ClosedTabsTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$ClosedTabsTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$ClosedTabsTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> id = const Value.absent(),
                Value<String> originalTabId = const Value.absent(),
                Value<String> customerName = const Value.absent(),
                Value<DateTime> closedAt = const Value.absent(),
                Value<PaymentMethod> paymentMethod = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => ClosedTabsCompanion(
                id: id,
                originalTabId: originalTabId,
                customerName: customerName,
                closedAt: closedAt,
                paymentMethod: paymentMethod,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String id,
                required String originalTabId,
                required String customerName,
                required DateTime closedAt,
                Value<PaymentMethod> paymentMethod = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => ClosedTabsCompanion.insert(
                id: id,
                originalTabId: originalTabId,
                customerName: customerName,
                closedAt: closedAt,
                paymentMethod: paymentMethod,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$ClosedTabsTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $ClosedTabsTable,
      ClosedTabsRow,
      $$ClosedTabsTableFilterComposer,
      $$ClosedTabsTableOrderingComposer,
      $$ClosedTabsTableAnnotationComposer,
      $$ClosedTabsTableCreateCompanionBuilder,
      $$ClosedTabsTableUpdateCompanionBuilder,
      (
        ClosedTabsRow,
        BaseReferences<_$AppDatabase, $ClosedTabsTable, ClosedTabsRow>,
      ),
      ClosedTabsRow,
      PrefetchHooks Function()
    >;
typedef $$ClosedTabItemsTableCreateCompanionBuilder =
    ClosedTabItemsCompanion Function({
      required String id,
      required String closedTabId,
      required String productId,
      required String productName,
      required int quantity,
      required int unitPriceInCents,
      Value<DateTime?> purchasedAt,
      Value<DateTime?> removedAt,
      Value<int> rowid,
    });
typedef $$ClosedTabItemsTableUpdateCompanionBuilder =
    ClosedTabItemsCompanion Function({
      Value<String> id,
      Value<String> closedTabId,
      Value<String> productId,
      Value<String> productName,
      Value<int> quantity,
      Value<int> unitPriceInCents,
      Value<DateTime?> purchasedAt,
      Value<DateTime?> removedAt,
      Value<int> rowid,
    });

class $$ClosedTabItemsTableFilterComposer
    extends Composer<_$AppDatabase, $ClosedTabItemsTable> {
  $$ClosedTabItemsTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnFilters(column),
  );

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

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

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

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

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

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

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

class $$ClosedTabItemsTableOrderingComposer
    extends Composer<_$AppDatabase, $ClosedTabItemsTable> {
  $$ClosedTabItemsTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

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

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

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

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

class $$ClosedTabItemsTableAnnotationComposer
    extends Composer<_$AppDatabase, $ClosedTabItemsTable> {
  $$ClosedTabItemsTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get id =>
      $composableBuilder(column: $table.id, builder: (column) => column);

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

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

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

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

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

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

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

class $$ClosedTabItemsTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $ClosedTabItemsTable,
          ClosedTabItemRow,
          $$ClosedTabItemsTableFilterComposer,
          $$ClosedTabItemsTableOrderingComposer,
          $$ClosedTabItemsTableAnnotationComposer,
          $$ClosedTabItemsTableCreateCompanionBuilder,
          $$ClosedTabItemsTableUpdateCompanionBuilder,
          (
            ClosedTabItemRow,
            BaseReferences<
              _$AppDatabase,
              $ClosedTabItemsTable,
              ClosedTabItemRow
            >,
          ),
          ClosedTabItemRow,
          PrefetchHooks Function()
        > {
  $$ClosedTabItemsTableTableManager(
    _$AppDatabase db,
    $ClosedTabItemsTable table,
  ) : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$ClosedTabItemsTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$ClosedTabItemsTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$ClosedTabItemsTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> id = const Value.absent(),
                Value<String> closedTabId = const Value.absent(),
                Value<String> productId = const Value.absent(),
                Value<String> productName = const Value.absent(),
                Value<int> quantity = const Value.absent(),
                Value<int> unitPriceInCents = const Value.absent(),
                Value<DateTime?> purchasedAt = const Value.absent(),
                Value<DateTime?> removedAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => ClosedTabItemsCompanion(
                id: id,
                closedTabId: closedTabId,
                productId: productId,
                productName: productName,
                quantity: quantity,
                unitPriceInCents: unitPriceInCents,
                purchasedAt: purchasedAt,
                removedAt: removedAt,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String id,
                required String closedTabId,
                required String productId,
                required String productName,
                required int quantity,
                required int unitPriceInCents,
                Value<DateTime?> purchasedAt = const Value.absent(),
                Value<DateTime?> removedAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => ClosedTabItemsCompanion.insert(
                id: id,
                closedTabId: closedTabId,
                productId: productId,
                productName: productName,
                quantity: quantity,
                unitPriceInCents: unitPriceInCents,
                purchasedAt: purchasedAt,
                removedAt: removedAt,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$ClosedTabItemsTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $ClosedTabItemsTable,
      ClosedTabItemRow,
      $$ClosedTabItemsTableFilterComposer,
      $$ClosedTabItemsTableOrderingComposer,
      $$ClosedTabItemsTableAnnotationComposer,
      $$ClosedTabItemsTableCreateCompanionBuilder,
      $$ClosedTabItemsTableUpdateCompanionBuilder,
      (
        ClosedTabItemRow,
        BaseReferences<_$AppDatabase, $ClosedTabItemsTable, ClosedTabItemRow>,
      ),
      ClosedTabItemRow,
      PrefetchHooks Function()
    >;
typedef $$AppSettingsTableTableCreateCompanionBuilder =
    AppSettingsTableCompanion Function({
      required String id,
      Value<bool> pinRequired,
      Value<bool> autoLockEnabled,
      Value<String> themeMode,
      Value<String> language,
      Value<int> barGridRows,
      Value<int> rowid,
    });
typedef $$AppSettingsTableTableUpdateCompanionBuilder =
    AppSettingsTableCompanion Function({
      Value<String> id,
      Value<bool> pinRequired,
      Value<bool> autoLockEnabled,
      Value<String> themeMode,
      Value<String> language,
      Value<int> barGridRows,
      Value<int> rowid,
    });

class $$AppSettingsTableTableFilterComposer
    extends Composer<_$AppDatabase, $AppSettingsTableTable> {
  $$AppSettingsTableTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnFilters(column),
  );

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

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

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

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

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

class $$AppSettingsTableTableOrderingComposer
    extends Composer<_$AppDatabase, $AppSettingsTableTable> {
  $$AppSettingsTableTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

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

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

class $$AppSettingsTableTableAnnotationComposer
    extends Composer<_$AppDatabase, $AppSettingsTableTable> {
  $$AppSettingsTableTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get id =>
      $composableBuilder(column: $table.id, builder: (column) => column);

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

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

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

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

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

class $$AppSettingsTableTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $AppSettingsTableTable,
          AppSettingsRow,
          $$AppSettingsTableTableFilterComposer,
          $$AppSettingsTableTableOrderingComposer,
          $$AppSettingsTableTableAnnotationComposer,
          $$AppSettingsTableTableCreateCompanionBuilder,
          $$AppSettingsTableTableUpdateCompanionBuilder,
          (
            AppSettingsRow,
            BaseReferences<
              _$AppDatabase,
              $AppSettingsTableTable,
              AppSettingsRow
            >,
          ),
          AppSettingsRow,
          PrefetchHooks Function()
        > {
  $$AppSettingsTableTableTableManager(
    _$AppDatabase db,
    $AppSettingsTableTable table,
  ) : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$AppSettingsTableTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$AppSettingsTableTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$AppSettingsTableTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> id = const Value.absent(),
                Value<bool> pinRequired = const Value.absent(),
                Value<bool> autoLockEnabled = const Value.absent(),
                Value<String> themeMode = const Value.absent(),
                Value<String> language = const Value.absent(),
                Value<int> barGridRows = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => AppSettingsTableCompanion(
                id: id,
                pinRequired: pinRequired,
                autoLockEnabled: autoLockEnabled,
                themeMode: themeMode,
                language: language,
                barGridRows: barGridRows,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String id,
                Value<bool> pinRequired = const Value.absent(),
                Value<bool> autoLockEnabled = const Value.absent(),
                Value<String> themeMode = const Value.absent(),
                Value<String> language = const Value.absent(),
                Value<int> barGridRows = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => AppSettingsTableCompanion.insert(
                id: id,
                pinRequired: pinRequired,
                autoLockEnabled: autoLockEnabled,
                themeMode: themeMode,
                language: language,
                barGridRows: barGridRows,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$AppSettingsTableTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $AppSettingsTableTable,
      AppSettingsRow,
      $$AppSettingsTableTableFilterComposer,
      $$AppSettingsTableTableOrderingComposer,
      $$AppSettingsTableTableAnnotationComposer,
      $$AppSettingsTableTableCreateCompanionBuilder,
      $$AppSettingsTableTableUpdateCompanionBuilder,
      (
        AppSettingsRow,
        BaseReferences<_$AppDatabase, $AppSettingsTableTable, AppSettingsRow>,
      ),
      AppSettingsRow,
      PrefetchHooks Function()
    >;
typedef $$RemoteSyncStateTableCreateCompanionBuilder =
    RemoteSyncStateCompanion Function({
      required String deviceId,
      Value<String?> serverCursor,
      Value<DateTime?> lastSuccessfulSyncAt,
      Value<DateTime?> lastAttemptedSyncAt,
      Value<int> consecutiveFailureCount,
      Value<int> rowid,
    });
typedef $$RemoteSyncStateTableUpdateCompanionBuilder =
    RemoteSyncStateCompanion Function({
      Value<String> deviceId,
      Value<String?> serverCursor,
      Value<DateTime?> lastSuccessfulSyncAt,
      Value<DateTime?> lastAttemptedSyncAt,
      Value<int> consecutiveFailureCount,
      Value<int> rowid,
    });

class $$RemoteSyncStateTableFilterComposer
    extends Composer<_$AppDatabase, $RemoteSyncStateTable> {
  $$RemoteSyncStateTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get deviceId => $composableBuilder(
    column: $table.deviceId,
    builder: (column) => ColumnFilters(column),
  );

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

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

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

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

class $$RemoteSyncStateTableOrderingComposer
    extends Composer<_$AppDatabase, $RemoteSyncStateTable> {
  $$RemoteSyncStateTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get deviceId => $composableBuilder(
    column: $table.deviceId,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

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

class $$RemoteSyncStateTableAnnotationComposer
    extends Composer<_$AppDatabase, $RemoteSyncStateTable> {
  $$RemoteSyncStateTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get deviceId =>
      $composableBuilder(column: $table.deviceId, builder: (column) => column);

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

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

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

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

class $$RemoteSyncStateTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $RemoteSyncStateTable,
          RemoteSyncStateRow,
          $$RemoteSyncStateTableFilterComposer,
          $$RemoteSyncStateTableOrderingComposer,
          $$RemoteSyncStateTableAnnotationComposer,
          $$RemoteSyncStateTableCreateCompanionBuilder,
          $$RemoteSyncStateTableUpdateCompanionBuilder,
          (
            RemoteSyncStateRow,
            BaseReferences<
              _$AppDatabase,
              $RemoteSyncStateTable,
              RemoteSyncStateRow
            >,
          ),
          RemoteSyncStateRow,
          PrefetchHooks Function()
        > {
  $$RemoteSyncStateTableTableManager(
    _$AppDatabase db,
    $RemoteSyncStateTable table,
  ) : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$RemoteSyncStateTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$RemoteSyncStateTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$RemoteSyncStateTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> deviceId = const Value.absent(),
                Value<String?> serverCursor = const Value.absent(),
                Value<DateTime?> lastSuccessfulSyncAt = const Value.absent(),
                Value<DateTime?> lastAttemptedSyncAt = const Value.absent(),
                Value<int> consecutiveFailureCount = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => RemoteSyncStateCompanion(
                deviceId: deviceId,
                serverCursor: serverCursor,
                lastSuccessfulSyncAt: lastSuccessfulSyncAt,
                lastAttemptedSyncAt: lastAttemptedSyncAt,
                consecutiveFailureCount: consecutiveFailureCount,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String deviceId,
                Value<String?> serverCursor = const Value.absent(),
                Value<DateTime?> lastSuccessfulSyncAt = const Value.absent(),
                Value<DateTime?> lastAttemptedSyncAt = const Value.absent(),
                Value<int> consecutiveFailureCount = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => RemoteSyncStateCompanion.insert(
                deviceId: deviceId,
                serverCursor: serverCursor,
                lastSuccessfulSyncAt: lastSuccessfulSyncAt,
                lastAttemptedSyncAt: lastAttemptedSyncAt,
                consecutiveFailureCount: consecutiveFailureCount,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$RemoteSyncStateTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $RemoteSyncStateTable,
      RemoteSyncStateRow,
      $$RemoteSyncStateTableFilterComposer,
      $$RemoteSyncStateTableOrderingComposer,
      $$RemoteSyncStateTableAnnotationComposer,
      $$RemoteSyncStateTableCreateCompanionBuilder,
      $$RemoteSyncStateTableUpdateCompanionBuilder,
      (
        RemoteSyncStateRow,
        BaseReferences<
          _$AppDatabase,
          $RemoteSyncStateTable,
          RemoteSyncStateRow
        >,
      ),
      RemoteSyncStateRow,
      PrefetchHooks Function()
    >;
typedef $$ProcessedRemoteCommandsTableCreateCompanionBuilder =
    ProcessedRemoteCommandsCompanion Function({
      required String commandId,
      required String commandType,
      required DateTime processedAt,
      required CommandResult result,
      Value<int> rowid,
    });
typedef $$ProcessedRemoteCommandsTableUpdateCompanionBuilder =
    ProcessedRemoteCommandsCompanion Function({
      Value<String> commandId,
      Value<String> commandType,
      Value<DateTime> processedAt,
      Value<CommandResult> result,
      Value<int> rowid,
    });

class $$ProcessedRemoteCommandsTableFilterComposer
    extends Composer<_$AppDatabase, $ProcessedRemoteCommandsTable> {
  $$ProcessedRemoteCommandsTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get commandId => $composableBuilder(
    column: $table.commandId,
    builder: (column) => ColumnFilters(column),
  );

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

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

  ColumnWithTypeConverterFilters<CommandResult, CommandResult, String>
  get result => $composableBuilder(
    column: $table.result,
    builder: (column) => ColumnWithTypeConverterFilters(column),
  );
}

class $$ProcessedRemoteCommandsTableOrderingComposer
    extends Composer<_$AppDatabase, $ProcessedRemoteCommandsTable> {
  $$ProcessedRemoteCommandsTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get commandId => $composableBuilder(
    column: $table.commandId,
    builder: (column) => ColumnOrderings(column),
  );

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

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

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

class $$ProcessedRemoteCommandsTableAnnotationComposer
    extends Composer<_$AppDatabase, $ProcessedRemoteCommandsTable> {
  $$ProcessedRemoteCommandsTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get commandId =>
      $composableBuilder(column: $table.commandId, builder: (column) => column);

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

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

  GeneratedColumnWithTypeConverter<CommandResult, String> get result =>
      $composableBuilder(column: $table.result, builder: (column) => column);
}

class $$ProcessedRemoteCommandsTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $ProcessedRemoteCommandsTable,
          ProcessedRemoteCommandRow,
          $$ProcessedRemoteCommandsTableFilterComposer,
          $$ProcessedRemoteCommandsTableOrderingComposer,
          $$ProcessedRemoteCommandsTableAnnotationComposer,
          $$ProcessedRemoteCommandsTableCreateCompanionBuilder,
          $$ProcessedRemoteCommandsTableUpdateCompanionBuilder,
          (
            ProcessedRemoteCommandRow,
            BaseReferences<
              _$AppDatabase,
              $ProcessedRemoteCommandsTable,
              ProcessedRemoteCommandRow
            >,
          ),
          ProcessedRemoteCommandRow,
          PrefetchHooks Function()
        > {
  $$ProcessedRemoteCommandsTableTableManager(
    _$AppDatabase db,
    $ProcessedRemoteCommandsTable table,
  ) : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$ProcessedRemoteCommandsTableFilterComposer(
                $db: db,
                $table: table,
              ),
          createOrderingComposer: () =>
              $$ProcessedRemoteCommandsTableOrderingComposer(
                $db: db,
                $table: table,
              ),
          createComputedFieldComposer: () =>
              $$ProcessedRemoteCommandsTableAnnotationComposer(
                $db: db,
                $table: table,
              ),
          updateCompanionCallback:
              ({
                Value<String> commandId = const Value.absent(),
                Value<String> commandType = const Value.absent(),
                Value<DateTime> processedAt = const Value.absent(),
                Value<CommandResult> result = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => ProcessedRemoteCommandsCompanion(
                commandId: commandId,
                commandType: commandType,
                processedAt: processedAt,
                result: result,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String commandId,
                required String commandType,
                required DateTime processedAt,
                required CommandResult result,
                Value<int> rowid = const Value.absent(),
              }) => ProcessedRemoteCommandsCompanion.insert(
                commandId: commandId,
                commandType: commandType,
                processedAt: processedAt,
                result: result,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$ProcessedRemoteCommandsTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $ProcessedRemoteCommandsTable,
      ProcessedRemoteCommandRow,
      $$ProcessedRemoteCommandsTableFilterComposer,
      $$ProcessedRemoteCommandsTableOrderingComposer,
      $$ProcessedRemoteCommandsTableAnnotationComposer,
      $$ProcessedRemoteCommandsTableCreateCompanionBuilder,
      $$ProcessedRemoteCommandsTableUpdateCompanionBuilder,
      (
        ProcessedRemoteCommandRow,
        BaseReferences<
          _$AppDatabase,
          $ProcessedRemoteCommandsTable,
          ProcessedRemoteCommandRow
        >,
      ),
      ProcessedRemoteCommandRow,
      PrefetchHooks Function()
    >;
typedef $$TabEventsTableCreateCompanionBuilder =
    TabEventsCompanion Function({
      required String id,
      required String payload,
      required DateTime createdAt,
      Value<int> rowid,
    });
typedef $$TabEventsTableUpdateCompanionBuilder =
    TabEventsCompanion Function({
      Value<String> id,
      Value<String> payload,
      Value<DateTime> createdAt,
      Value<int> rowid,
    });

class $$TabEventsTableFilterComposer
    extends Composer<_$AppDatabase, $TabEventsTable> {
  $$TabEventsTableFilterComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnFilters<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnFilters(column),
  );

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

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

class $$TabEventsTableOrderingComposer
    extends Composer<_$AppDatabase, $TabEventsTable> {
  $$TabEventsTableOrderingComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  ColumnOrderings<String> get id => $composableBuilder(
    column: $table.id,
    builder: (column) => ColumnOrderings(column),
  );

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

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

class $$TabEventsTableAnnotationComposer
    extends Composer<_$AppDatabase, $TabEventsTable> {
  $$TabEventsTableAnnotationComposer({
    required super.$db,
    required super.$table,
    super.joinBuilder,
    super.$addJoinBuilderToRootComposer,
    super.$removeJoinBuilderFromRootComposer,
  });
  GeneratedColumn<String> get id =>
      $composableBuilder(column: $table.id, builder: (column) => column);

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

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

class $$TabEventsTableTableManager
    extends
        RootTableManager<
          _$AppDatabase,
          $TabEventsTable,
          TabEventRow,
          $$TabEventsTableFilterComposer,
          $$TabEventsTableOrderingComposer,
          $$TabEventsTableAnnotationComposer,
          $$TabEventsTableCreateCompanionBuilder,
          $$TabEventsTableUpdateCompanionBuilder,
          (
            TabEventRow,
            BaseReferences<_$AppDatabase, $TabEventsTable, TabEventRow>,
          ),
          TabEventRow,
          PrefetchHooks Function()
        > {
  $$TabEventsTableTableManager(_$AppDatabase db, $TabEventsTable table)
    : super(
        TableManagerState(
          db: db,
          table: table,
          createFilteringComposer: () =>
              $$TabEventsTableFilterComposer($db: db, $table: table),
          createOrderingComposer: () =>
              $$TabEventsTableOrderingComposer($db: db, $table: table),
          createComputedFieldComposer: () =>
              $$TabEventsTableAnnotationComposer($db: db, $table: table),
          updateCompanionCallback:
              ({
                Value<String> id = const Value.absent(),
                Value<String> payload = const Value.absent(),
                Value<DateTime> createdAt = const Value.absent(),
                Value<int> rowid = const Value.absent(),
              }) => TabEventsCompanion(
                id: id,
                payload: payload,
                createdAt: createdAt,
                rowid: rowid,
              ),
          createCompanionCallback:
              ({
                required String id,
                required String payload,
                required DateTime createdAt,
                Value<int> rowid = const Value.absent(),
              }) => TabEventsCompanion.insert(
                id: id,
                payload: payload,
                createdAt: createdAt,
                rowid: rowid,
              ),
          withReferenceMapper: (p0) => p0
              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
              .toList(),
          prefetchHooksCallback: null,
        ),
      );
}

typedef $$TabEventsTableProcessedTableManager =
    ProcessedTableManager<
      _$AppDatabase,
      $TabEventsTable,
      TabEventRow,
      $$TabEventsTableFilterComposer,
      $$TabEventsTableOrderingComposer,
      $$TabEventsTableAnnotationComposer,
      $$TabEventsTableCreateCompanionBuilder,
      $$TabEventsTableUpdateCompanionBuilder,
      (
        TabEventRow,
        BaseReferences<_$AppDatabase, $TabEventsTable, TabEventRow>,
      ),
      TabEventRow,
      PrefetchHooks Function()
    >;

class $AppDatabaseManager {
  final _$AppDatabase _db;
  $AppDatabaseManager(this._db);
  $$ProductsTableTableManager get products =>
      $$ProductsTableTableManager(_db, _db.products);
  $$BarTabsTableTableManager get barTabs =>
      $$BarTabsTableTableManager(_db, _db.barTabs);
  $$TabItemsTableTableManager get tabItems =>
      $$TabItemsTableTableManager(_db, _db.tabItems);
  $$TabItemPurchasesTableTableManager get tabItemPurchases =>
      $$TabItemPurchasesTableTableManager(_db, _db.tabItemPurchases);
  $$ClosedTabsTableTableManager get closedTabs =>
      $$ClosedTabsTableTableManager(_db, _db.closedTabs);
  $$ClosedTabItemsTableTableManager get closedTabItems =>
      $$ClosedTabItemsTableTableManager(_db, _db.closedTabItems);
  $$AppSettingsTableTableTableManager get appSettingsTable =>
      $$AppSettingsTableTableTableManager(_db, _db.appSettingsTable);
  $$RemoteSyncStateTableTableManager get remoteSyncState =>
      $$RemoteSyncStateTableTableManager(_db, _db.remoteSyncState);
  $$ProcessedRemoteCommandsTableTableManager get processedRemoteCommands =>
      $$ProcessedRemoteCommandsTableTableManager(
        _db,
        _db.processedRemoteCommands,
      );
  $$TabEventsTableTableManager get tabEvents =>
      $$TabEventsTableTableManager(_db, _db.tabEvents);
}