package world.respect.datalayer.db

import androidx.room.InvalidationTracker
import androidx.room.RoomOpenDelegate
import androidx.room.migration.AutoMigrationSpec
import androidx.room.migration.Migration
import androidx.room.util.TableInfo
import androidx.room.util.TableInfo.Companion.read
import androidx.room.util.dropFtsSyncTriggers
import androidx.sqlite.SQLiteConnection
import androidx.sqlite.execSQL
import javax.`annotation`.processing.Generated
import kotlin.Lazy
import kotlin.String
import kotlin.Suppress
import kotlin.collections.List
import kotlin.collections.Map
import kotlin.collections.MutableList
import kotlin.collections.MutableMap
import kotlin.collections.MutableSet
import kotlin.collections.Set
import kotlin.collections.mutableListOf
import kotlin.collections.mutableMapOf
import kotlin.collections.mutableSetOf
import kotlin.reflect.KClass
import world.respect.datalayer.db.school.daos.AssignmentEntityDao
import world.respect.datalayer.db.school.daos.AssignmentEntityDao_Impl
import world.respect.datalayer.db.school.daos.AssignmentLearningResourceRefEntityDao
import world.respect.datalayer.db.school.daos.AssignmentLearningResourceRefEntityDao_Impl
import world.respect.datalayer.db.school.daos.AuthTokenEntityDao
import world.respect.datalayer.db.school.daos.AuthTokenEntityDao_Impl
import world.respect.datalayer.db.school.daos.ClassEntityDao
import world.respect.datalayer.db.school.daos.ClassEntityDao_Impl
import world.respect.datalayer.db.school.daos.ClassPermissionEntityDao
import world.respect.datalayer.db.school.daos.ClassPermissionEntityDao_Impl
import world.respect.datalayer.db.school.daos.EnrollmentEntityDao
import world.respect.datalayer.db.school.daos.EnrollmentEntityDao_Impl
import world.respect.datalayer.db.school.daos.IndicatorEntityDao
import world.respect.datalayer.db.school.daos.IndicatorEntityDao_Impl
import world.respect.datalayer.db.school.daos.InviteEntityDao
import world.respect.datalayer.db.school.daos.InviteEntityDao_Impl
import world.respect.datalayer.db.school.daos.PersonEntityDao
import world.respect.datalayer.db.school.daos.PersonEntityDao_Impl
import world.respect.datalayer.db.school.daos.PersonPasswordEntityDao
import world.respect.datalayer.db.school.daos.PersonPasswordEntityDao_Impl
import world.respect.datalayer.db.school.daos.PersonQrBadgeEntityDao
import world.respect.datalayer.db.school.daos.PersonQrBadgeEntityDao_Impl
import world.respect.datalayer.db.school.daos.PersonRelatedPersonEntityDao
import world.respect.datalayer.db.school.daos.PersonRelatedPersonEntityDao_Impl
import world.respect.datalayer.db.school.daos.PersonRoleEntityDao
import world.respect.datalayer.db.school.daos.PersonRoleEntityDao_Impl
import world.respect.datalayer.db.school.daos.PullSyncStatusEntityDao
import world.respect.datalayer.db.school.daos.PullSyncStatusEntityDao_Impl
import world.respect.datalayer.db.school.daos.ReportEntityDao
import world.respect.datalayer.db.school.daos.ReportEntityDao_Impl
import world.respect.datalayer.db.school.daos.SchoolAppEntityDao
import world.respect.datalayer.db.school.daos.SchoolAppEntityDao_Impl
import world.respect.datalayer.db.school.daos.SchoolPermissionGrantDao
import world.respect.datalayer.db.school.daos.SchoolPermissionGrantDao_Impl
import world.respect.datalayer.db.school.daos.WriteQueueItemEntityDao
import world.respect.datalayer.db.school.daos.WriteQueueItemEntityDao_Impl
import world.respect.datalayer.db.school.opds.daos.OpdsFeedEntityDao
import world.respect.datalayer.db.school.opds.daos.OpdsFeedEntityDao_Impl
import world.respect.datalayer.db.school.opds.daos.OpdsFeedMetadataEntityDao
import world.respect.datalayer.db.school.opds.daos.OpdsFeedMetadataEntityDao_Impl
import world.respect.datalayer.db.school.opds.daos.OpdsGroupEntityDao
import world.respect.datalayer.db.school.opds.daos.OpdsGroupEntityDao_Impl
import world.respect.datalayer.db.school.opds.daos.OpdsPublicationEntityDao
import world.respect.datalayer.db.school.opds.daos.OpdsPublicationEntityDao_Impl
import world.respect.datalayer.db.school.opds.daos.PersonPasskeyEntityDao
import world.respect.datalayer.db.school.opds.daos.PersonPasskeyEntityDao_Impl
import world.respect.datalayer.db.school.opds.daos.ReadiumLinkEntityDao
import world.respect.datalayer.db.school.opds.daos.ReadiumLinkEntityDao_Impl
import world.respect.datalayer.db.shared.daos.LangMapEntityDao
import world.respect.datalayer.db.shared.daos.LangMapEntityDao_Impl

@Generated(value = ["androidx.room.RoomProcessor"])
@Suppress(names = ["UNCHECKED_CAST", "DEPRECATION", "REDUNDANT_PROJECTION", "REMOVAL"])
public class RespectSchoolDatabase_Impl : RespectSchoolDatabase() {
  private val _schoolAppEntityDao: Lazy<SchoolAppEntityDao> = lazy {
    SchoolAppEntityDao_Impl(this)
  }

  private val _personEntityDao: Lazy<PersonEntityDao> = lazy {
    PersonEntityDao_Impl(this)
  }

  private val _personPasswordEntityDao: Lazy<PersonPasswordEntityDao> = lazy {
    PersonPasswordEntityDao_Impl(this)
  }

  private val _personQrBadgeEntityDao: Lazy<PersonQrBadgeEntityDao> = lazy {
    PersonQrBadgeEntityDao_Impl(this)
  }

  private val _personPasskeyEntityDao: Lazy<PersonPasskeyEntityDao> = lazy {
    PersonPasskeyEntityDao_Impl(this)
  }

  private val _authTokenEntityDao: Lazy<AuthTokenEntityDao> = lazy {
    AuthTokenEntityDao_Impl(this)
  }

  private val _personRoleEntityDao: Lazy<PersonRoleEntityDao> = lazy {
    PersonRoleEntityDao_Impl(this)
  }

  private val _personRelatedPersonEntityDao: Lazy<PersonRelatedPersonEntityDao> = lazy {
    PersonRelatedPersonEntityDao_Impl(this)
  }

  private val _reportEntityDao: Lazy<ReportEntityDao> = lazy {
    ReportEntityDao_Impl(this)
  }

  private val _indicatorEntityDao: Lazy<IndicatorEntityDao> = lazy {
    IndicatorEntityDao_Impl(this)
  }

  private val _classEntityDao: Lazy<ClassEntityDao> = lazy {
    ClassEntityDao_Impl(this)
  }

  private val _classPermissionEntityDao: Lazy<ClassPermissionEntityDao> = lazy {
    ClassPermissionEntityDao_Impl(this)
  }

  private val _enrollmentEntityDao: Lazy<EnrollmentEntityDao> = lazy {
    EnrollmentEntityDao_Impl(this)
  }

  private val _assignmentEntityDao: Lazy<AssignmentEntityDao> = lazy {
    AssignmentEntityDao_Impl(this)
  }

  private val _assignmentLearningResourceRefEntityDao: Lazy<AssignmentLearningResourceRefEntityDao>
      = lazy {
    AssignmentLearningResourceRefEntityDao_Impl(this)
  }

  private val _writeQueueItemEntityDao: Lazy<WriteQueueItemEntityDao> = lazy {
    WriteQueueItemEntityDao_Impl(this)
  }

  private val _inviteEntityDao: Lazy<InviteEntityDao> = lazy {
    InviteEntityDao_Impl(this)
  }

  private val _schoolPermissionGrantDao: Lazy<SchoolPermissionGrantDao> = lazy {
    SchoolPermissionGrantDao_Impl(this)
  }

  private val _pullSyncStatusEntityDao: Lazy<PullSyncStatusEntityDao> = lazy {
    PullSyncStatusEntityDao_Impl(this)
  }

  private val _langMapEntityDao: Lazy<LangMapEntityDao> = lazy {
    LangMapEntityDao_Impl(this)
  }

  private val _opdsFeedEntityDao: Lazy<OpdsFeedEntityDao> = lazy {
    OpdsFeedEntityDao_Impl(this)
  }

  private val _opdsPublicationEntityDao: Lazy<OpdsPublicationEntityDao> = lazy {
    OpdsPublicationEntityDao_Impl(this)
  }

  private val _opdsFeedMetadataEntityDao: Lazy<OpdsFeedMetadataEntityDao> = lazy {
    OpdsFeedMetadataEntityDao_Impl(this)
  }

  private val _readiumLinkEntityDao: Lazy<ReadiumLinkEntityDao> = lazy {
    ReadiumLinkEntityDao_Impl(this)
  }

  private val _opdsGroupEntityDao: Lazy<OpdsGroupEntityDao> = lazy {
    OpdsGroupEntityDao_Impl(this)
  }

  protected override fun createOpenDelegate(): RoomOpenDelegate {
    val _openDelegate: RoomOpenDelegate = object : RoomOpenDelegate(12, "3cd745bbc0ddf2c692bd454cbb19fc7f", "c4867bf70009cb11587f00ed38150ae4") {
      public override fun createAllTables(connection: SQLiteConnection) {
        connection.execSQL("CREATE TABLE IF NOT EXISTS `SchoolAppEntity` (`saUid` TEXT NOT NULL, `saUidNum` INTEGER NOT NULL, `saManifestUrl` TEXT NOT NULL, `saStatus` INTEGER NOT NULL, `saLastModified` INTEGER NOT NULL, `saStored` INTEGER NOT NULL, PRIMARY KEY(`saUidNum`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `PersonEntity` (`pGuid` TEXT NOT NULL, `pGuidHash` INTEGER NOT NULL, `pActive` INTEGER NOT NULL, `pStatus` INTEGER NOT NULL, `pLastModified` INTEGER NOT NULL, `pStored` INTEGER NOT NULL, `pMetadata` TEXT, `pUsername` TEXT, `pGivenName` TEXT NOT NULL, `pFamilyName` TEXT NOT NULL, `pMiddleName` TEXT, `pGender` INTEGER NOT NULL, `pDateOfBirth` INTEGER, `pEmail` TEXT, `pPhoneNumber` TEXT, PRIMARY KEY(`pGuidHash`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `PersonRoleEntity` (`prUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `prPersonGuidHash` INTEGER NOT NULL, `prIsPrimaryRole` INTEGER NOT NULL, `prRoleEnum` INTEGER NOT NULL, `prBeginDate` INTEGER, `prEndDate` INTEGER)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `PersonRelatedPersonEntity` (`prpUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `prpPersonUidNum` INTEGER NOT NULL, `prpOtherPersonUid` TEXT NOT NULL, `prpOtherPersonUidNum` INTEGER NOT NULL)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `PersonPasswordEntity` (`ppwGuidNum` INTEGER NOT NULL, `ppwGuid` TEXT NOT NULL, `authAlgorithm` TEXT NOT NULL, `authEncoded` TEXT NOT NULL, `authSalt` TEXT NOT NULL, `authIterations` INTEGER NOT NULL, `authKeyLen` INTEGER NOT NULL, `ppwLastModified` INTEGER NOT NULL, `ppwStored` INTEGER NOT NULL, PRIMARY KEY(`ppwGuidNum`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `PersonPasskeyEntity` (`ppPersonUidNum` INTEGER NOT NULL, `ppCredentialId` TEXT NOT NULL, `ppLastModified` INTEGER NOT NULL, `ppStored` INTEGER NOT NULL, `ppAttestationObj` TEXT, `ppClientDataJson` TEXT, `ppOriginString` TEXT, `ppChallengeString` TEXT, `ppPublicKey` TEXT, `isRevoked` INTEGER NOT NULL, `ppDeviceName` TEXT NOT NULL DEFAULT '', `ppTimeCreated` INTEGER NOT NULL DEFAULT 0, `ppAaguid` TEXT NOT NULL DEFAULT '', `ppProviderName` TEXT NOT NULL DEFAULT '', `ppIconLight` TEXT NOT NULL DEFAULT '', `ppIconDark` TEXT NOT NULL DEFAULT '', PRIMARY KEY(`ppPersonUidNum`, `ppCredentialId`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `AuthTokenEntity` (`atUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `atPGuidHash` INTEGER NOT NULL, `atPGuid` TEXT NOT NULL, `atCode` TEXT, `atToken` TEXT NOT NULL, `atTimeCreated` INTEGER NOT NULL, `atTtl` INTEGER NOT NULL, `atPlatform` TEXT, `atAndroidSdkInt` INTEGER, `atVersion` TEXT, `atManufacturer` TEXT, `atModel` TEXT, `atRam` INTEGER)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `ReportEntity` (`rGuid` TEXT NOT NULL, `rOwnerGuid` TEXT NOT NULL, `rTitle` TEXT NOT NULL, `rOptions` TEXT NOT NULL, `rIsTemplate` INTEGER NOT NULL, `rActive` INTEGER NOT NULL, `rLastModified` INTEGER NOT NULL, `rStored` INTEGER NOT NULL, PRIMARY KEY(`rGuid`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `IndicatorEntity` (`indicatorId` TEXT NOT NULL, `name` TEXT NOT NULL, `description` TEXT NOT NULL, `type` TEXT NOT NULL, `sql` TEXT NOT NULL, PRIMARY KEY(`indicatorId`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `ClassEntity` (`cGuid` TEXT NOT NULL, `cGuidHash` INTEGER NOT NULL, `cTitle` TEXT NOT NULL, `cStatus` INTEGER NOT NULL, `cDescription` TEXT, `cLastModified` INTEGER NOT NULL, `cStored` INTEGER NOT NULL, `cTeacherInviteGuid` TEXT, `cStudentInviteGuid` TEXT, PRIMARY KEY(`cGuidHash`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `ClassPermissionEntity` (`cpeId` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `cpeClassUidNum` INTEGER NOT NULL, `cpeToEnrollmentRole` INTEGER, `cpePermissions` INTEGER NOT NULL)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `EnrollmentEntity` (`eUid` TEXT NOT NULL, `eUidNum` INTEGER NOT NULL, `eStatus` INTEGER NOT NULL, `eLastModified` INTEGER NOT NULL, `eStored` INTEGER NOT NULL, `eMetadata` TEXT, `eClassUid` TEXT NOT NULL, `eClassUidNum` INTEGER NOT NULL, `ePersonUid` TEXT NOT NULL, `ePersonUidNum` INTEGER NOT NULL, `eRole` INTEGER NOT NULL, `eBeginDate` INTEGER, `eEndDate` INTEGER, `eRemovedAt` INTEGER, `eInviteCode` TEXT, `eApprovedByPersonUidNum` INTEGER NOT NULL, `eApprovedByPersonUid` TEXT, PRIMARY KEY(`eUidNum`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `AssignmentEntity` (`aeUid` TEXT NOT NULL, `aeUidNum` INTEGER NOT NULL, `aeTitle` TEXT NOT NULL, `aeDescription` TEXT NOT NULL, `aeClassUid` TEXT NOT NULL, `aeClassUidNum` INTEGER NOT NULL, `aeDeadline` INTEGER, `aeLastModified` INTEGER NOT NULL, `aeStored` INTEGER NOT NULL, PRIMARY KEY(`aeUidNum`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `AssignmentLearningResourceRefEntity` (`alrrAeUidNum` INTEGER NOT NULL, `alrrLearningUnitManifestUrlHash` INTEGER NOT NULL, `alrrLearningUnitManifestUrl` TEXT NOT NULL, `alrrAppManifestUrl` TEXT NOT NULL, PRIMARY KEY(`alrrAeUidNum`, `alrrLearningUnitManifestUrlHash`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `WriteQueueItemEntity` (`wqiQueueItemId` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `wqiModel` INTEGER NOT NULL, `wqiUid` TEXT NOT NULL, `wqiTimeQueued` INTEGER NOT NULL, `wqiAttemptCount` INTEGER NOT NULL, `wqiTimeWritten` INTEGER NOT NULL, `wqiAccountGuid` TEXT NOT NULL)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `SchoolPermissionGrantEntity` (`spgUid` TEXT NOT NULL, `spgUidNum` INTEGER NOT NULL, `spgStatusEnum` INTEGER NOT NULL, `spgToRole` INTEGER NOT NULL, `spgPermissions` INTEGER NOT NULL, `spgLastModified` INTEGER NOT NULL, `spgStored` INTEGER NOT NULL, PRIMARY KEY(`spgUidNum`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `PullSyncStatusEntity` (`pssAccountPersonUid` TEXT NOT NULL, `pssAccountPersonUidNum` INTEGER NOT NULL, `pssTableId` INTEGER NOT NULL, `pssLastConsistentThrough` INTEGER NOT NULL, `pssPermissionsLastModified` INTEGER NOT NULL, PRIMARY KEY(`pssAccountPersonUid`, `pssTableId`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `PersonQrBadgeEntity` (`pqrGuidNum` INTEGER NOT NULL, `pqrGuid` TEXT NOT NULL, `pqrLastModified` INTEGER NOT NULL, `pqrStored` INTEGER NOT NULL, `pqrQrCodeUrl` TEXT, `pqrStatus` INTEGER NOT NULL, PRIMARY KEY(`pqrGuidNum`))")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `index_PersonQrBadgeEntity_pqrQrCodeUrl` ON `PersonQrBadgeEntity` (`pqrQrCodeUrl`)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `InviteEntity` (`iGuid` TEXT NOT NULL, `iGuidHash` INTEGER NOT NULL, `iCode` TEXT NOT NULL, `iApprovalRequiredAfter` INTEGER NOT NULL, `iLastModified` INTEGER NOT NULL, `iStored` INTEGER NOT NULL, `iStatus` INTEGER NOT NULL, `iNewUserRole` INTEGER, `iNewUserFirstInvite` INTEGER NOT NULL, `iForFamilyOfGuid` TEXT, `iForFamilyOfGuidHash` INTEGER, `iForClassGuid` TEXT, `iForClassName` TEXT, `iInviteMode` INTEGER, `iSchoolName` TEXT, `iForClassGuidHash` INTEGER, `iForClassRole` INTEGER, PRIMARY KEY(`iGuidHash`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `LangMapEntity` (`lmeId` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `lmeTopParentType` INTEGER NOT NULL, `lmeTopParentUid1` INTEGER NOT NULL, `lmeTopParentUid2` INTEGER NOT NULL, `lmePropType` INTEGER NOT NULL, `lmePropFk` INTEGER NOT NULL, `lmeLang` TEXT NOT NULL, `lmeRegion` TEXT, `lmeValue` TEXT NOT NULL)")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `index_LangMapEntity_lmeTopParentType_lmeTopParentUid1_lmeTopParentUid2_lmePropType` ON `LangMapEntity` (`lmeTopParentType`, `lmeTopParentUid1`, `lmeTopParentUid2`, `lmePropType`)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `ReadiumLinkEntity` (`rleId` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `rleOpdsParentType` INTEGER NOT NULL, `rleOpdsParentUid` INTEGER NOT NULL, `rlePropType` TEXT NOT NULL, `rlePropFk` INTEGER NOT NULL, `rleIndex` INTEGER NOT NULL, `rleHref` TEXT NOT NULL, `rleRel` TEXT, `rleType` TEXT, `rleTitle` TEXT, `rleTemplated` INTEGER, `rleProperties` TEXT, `rleHeight` INTEGER, `rleWidth` INTEGER, `rleSize` INTEGER, `rleBitrate` REAL, `rleDuration` REAL, `rleLanguage` TEXT)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `OpdsPublicationEntity` (`opeUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `opeOfeUid` INTEGER NOT NULL, `opeOgeUid` INTEGER NOT NULL, `opeIndex` INTEGER NOT NULL, `opeUrl` TEXT, `opeUrlHash` INTEGER NOT NULL, `opeLastModified` INTEGER NOT NULL, `opeEtag` TEXT, `opeMdIdentifier` TEXT, `opeMdLanguage` TEXT, `opeMdType` TEXT, `opeMdDescription` TEXT, `opeMdNumberOfPages` INTEGER, `opeMdDuration` REAL)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `ReadiumSubjectEntity` (`rseUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `rseStringValue` TEXT, `rseTopParentType` INTEGER NOT NULL, `rseTopParentUid` INTEGER NOT NULL, `rseSubjectSortAs` TEXT, `rseSubjectCode` TEXT, `rseSubjectScheme` TEXT, `rseIndex` INTEGER NOT NULL)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `OpdsFacetEntity` (`ofaeUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `ofaeOfeUid` INTEGER NOT NULL)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `OpdsGroupEntity` (`ogeUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `ogeOfeUid` INTEGER NOT NULL, `ogeIndex` INTEGER NOT NULL)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `OpdsFeedEntity` (`ofeUid` INTEGER NOT NULL, `ofeUrl` TEXT NOT NULL, `ofeUrlHash` INTEGER NOT NULL, `ofeLastModified` INTEGER NOT NULL, `ofeLastModifiedHeader` INTEGER NOT NULL, `ofeEtag` TEXT, `ofeStored` INTEGER NOT NULL, PRIMARY KEY(`ofeUid`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `OpdsFeedMetadataEntity` (`ofmeUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `ofmeOfeUid` INTEGER NOT NULL, `ofmePropType` INTEGER NOT NULL, `ofmePropFk` INTEGER NOT NULL, `ofmeIdentifier` TEXT, `ofmeType` TEXT, `ofmeTitle` TEXT NOT NULL, `ofmeSubtitle` TEXT, `ofmeModified` INTEGER, `ofmeDescription` TEXT, `ofmeItemsPerPage` INTEGER, `ofmeCurrentPage` INTEGER, `ofmeNumberOfItems` INTEGER)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)")
        connection.execSQL("INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '3cd745bbc0ddf2c692bd454cbb19fc7f')")
      }

      public override fun dropAllTables(connection: SQLiteConnection) {
        connection.execSQL("DROP TABLE IF EXISTS `SchoolAppEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `PersonEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `PersonRoleEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `PersonRelatedPersonEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `PersonPasswordEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `PersonPasskeyEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `AuthTokenEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `ReportEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `IndicatorEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `ClassEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `ClassPermissionEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `EnrollmentEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `AssignmentEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `AssignmentLearningResourceRefEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `WriteQueueItemEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `SchoolPermissionGrantEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `PullSyncStatusEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `PersonQrBadgeEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `InviteEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `LangMapEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `ReadiumLinkEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `OpdsPublicationEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `ReadiumSubjectEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `OpdsFacetEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `OpdsGroupEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `OpdsFeedEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `OpdsFeedMetadataEntity`")
      }

      public override fun onCreate(connection: SQLiteConnection) {
      }

      public override fun onOpen(connection: SQLiteConnection) {
        internalInitInvalidationTracker(connection)
      }

      public override fun onPreMigrate(connection: SQLiteConnection) {
        dropFtsSyncTriggers(connection)
      }

      public override fun onPostMigrate(connection: SQLiteConnection) {
      }

      public override fun onValidateSchema(connection: SQLiteConnection): RoomOpenDelegate.ValidationResult {
        val _columnsSchoolAppEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsSchoolAppEntity.put("saUid", TableInfo.Column("saUid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsSchoolAppEntity.put("saUidNum", TableInfo.Column("saUidNum", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsSchoolAppEntity.put("saManifestUrl", TableInfo.Column("saManifestUrl", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsSchoolAppEntity.put("saStatus", TableInfo.Column("saStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsSchoolAppEntity.put("saLastModified", TableInfo.Column("saLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsSchoolAppEntity.put("saStored", TableInfo.Column("saStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysSchoolAppEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesSchoolAppEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoSchoolAppEntity: TableInfo = TableInfo("SchoolAppEntity", _columnsSchoolAppEntity, _foreignKeysSchoolAppEntity, _indicesSchoolAppEntity)
        val _existingSchoolAppEntity: TableInfo = read(connection, "SchoolAppEntity")
        if (!_infoSchoolAppEntity.equals(_existingSchoolAppEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |SchoolAppEntity(world.respect.datalayer.db.school.entities.SchoolAppEntity).
              | Expected:
              |""".trimMargin() + _infoSchoolAppEntity + """
              |
              | Found:
              |""".trimMargin() + _existingSchoolAppEntity)
        }
        val _columnsPersonEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsPersonEntity.put("pGuid", TableInfo.Column("pGuid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pGuidHash", TableInfo.Column("pGuidHash", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pActive", TableInfo.Column("pActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pStatus", TableInfo.Column("pStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pLastModified", TableInfo.Column("pLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pStored", TableInfo.Column("pStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pMetadata", TableInfo.Column("pMetadata", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pUsername", TableInfo.Column("pUsername", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pGivenName", TableInfo.Column("pGivenName", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pFamilyName", TableInfo.Column("pFamilyName", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pMiddleName", TableInfo.Column("pMiddleName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pGender", TableInfo.Column("pGender", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pDateOfBirth", TableInfo.Column("pDateOfBirth", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pEmail", TableInfo.Column("pEmail", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonEntity.put("pPhoneNumber", TableInfo.Column("pPhoneNumber", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysPersonEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesPersonEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoPersonEntity: TableInfo = TableInfo("PersonEntity", _columnsPersonEntity, _foreignKeysPersonEntity, _indicesPersonEntity)
        val _existingPersonEntity: TableInfo = read(connection, "PersonEntity")
        if (!_infoPersonEntity.equals(_existingPersonEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |PersonEntity(world.respect.datalayer.db.school.entities.PersonEntity).
              | Expected:
              |""".trimMargin() + _infoPersonEntity + """
              |
              | Found:
              |""".trimMargin() + _existingPersonEntity)
        }
        val _columnsPersonRoleEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsPersonRoleEntity.put("prUid", TableInfo.Column("prUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonRoleEntity.put("prPersonGuidHash", TableInfo.Column("prPersonGuidHash", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonRoleEntity.put("prIsPrimaryRole", TableInfo.Column("prIsPrimaryRole", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonRoleEntity.put("prRoleEnum", TableInfo.Column("prRoleEnum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonRoleEntity.put("prBeginDate", TableInfo.Column("prBeginDate", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonRoleEntity.put("prEndDate", TableInfo.Column("prEndDate", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysPersonRoleEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesPersonRoleEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoPersonRoleEntity: TableInfo = TableInfo("PersonRoleEntity", _columnsPersonRoleEntity, _foreignKeysPersonRoleEntity, _indicesPersonRoleEntity)
        val _existingPersonRoleEntity: TableInfo = read(connection, "PersonRoleEntity")
        if (!_infoPersonRoleEntity.equals(_existingPersonRoleEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |PersonRoleEntity(world.respect.datalayer.db.school.entities.PersonRoleEntity).
              | Expected:
              |""".trimMargin() + _infoPersonRoleEntity + """
              |
              | Found:
              |""".trimMargin() + _existingPersonRoleEntity)
        }
        val _columnsPersonRelatedPersonEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsPersonRelatedPersonEntity.put("prpUid", TableInfo.Column("prpUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonRelatedPersonEntity.put("prpPersonUidNum", TableInfo.Column("prpPersonUidNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonRelatedPersonEntity.put("prpOtherPersonUid", TableInfo.Column("prpOtherPersonUid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonRelatedPersonEntity.put("prpOtherPersonUidNum", TableInfo.Column("prpOtherPersonUidNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysPersonRelatedPersonEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesPersonRelatedPersonEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoPersonRelatedPersonEntity: TableInfo = TableInfo("PersonRelatedPersonEntity", _columnsPersonRelatedPersonEntity, _foreignKeysPersonRelatedPersonEntity, _indicesPersonRelatedPersonEntity)
        val _existingPersonRelatedPersonEntity: TableInfo = read(connection, "PersonRelatedPersonEntity")
        if (!_infoPersonRelatedPersonEntity.equals(_existingPersonRelatedPersonEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |PersonRelatedPersonEntity(world.respect.datalayer.db.school.entities.PersonRelatedPersonEntity).
              | Expected:
              |""".trimMargin() + _infoPersonRelatedPersonEntity + """
              |
              | Found:
              |""".trimMargin() + _existingPersonRelatedPersonEntity)
        }
        val _columnsPersonPasswordEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsPersonPasswordEntity.put("ppwGuidNum", TableInfo.Column("ppwGuidNum", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasswordEntity.put("ppwGuid", TableInfo.Column("ppwGuid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasswordEntity.put("authAlgorithm", TableInfo.Column("authAlgorithm", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasswordEntity.put("authEncoded", TableInfo.Column("authEncoded", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasswordEntity.put("authSalt", TableInfo.Column("authSalt", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasswordEntity.put("authIterations", TableInfo.Column("authIterations", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasswordEntity.put("authKeyLen", TableInfo.Column("authKeyLen", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasswordEntity.put("ppwLastModified", TableInfo.Column("ppwLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasswordEntity.put("ppwStored", TableInfo.Column("ppwStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysPersonPasswordEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesPersonPasswordEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoPersonPasswordEntity: TableInfo = TableInfo("PersonPasswordEntity", _columnsPersonPasswordEntity, _foreignKeysPersonPasswordEntity, _indicesPersonPasswordEntity)
        val _existingPersonPasswordEntity: TableInfo = read(connection, "PersonPasswordEntity")
        if (!_infoPersonPasswordEntity.equals(_existingPersonPasswordEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |PersonPasswordEntity(world.respect.datalayer.db.school.entities.PersonPasswordEntity).
              | Expected:
              |""".trimMargin() + _infoPersonPasswordEntity + """
              |
              | Found:
              |""".trimMargin() + _existingPersonPasswordEntity)
        }
        val _columnsPersonPasskeyEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsPersonPasskeyEntity.put("ppPersonUidNum", TableInfo.Column("ppPersonUidNum", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppCredentialId", TableInfo.Column("ppCredentialId", "TEXT", true, 2, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppLastModified", TableInfo.Column("ppLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppStored", TableInfo.Column("ppStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppAttestationObj", TableInfo.Column("ppAttestationObj", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppClientDataJson", TableInfo.Column("ppClientDataJson", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppOriginString", TableInfo.Column("ppOriginString", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppChallengeString", TableInfo.Column("ppChallengeString", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppPublicKey", TableInfo.Column("ppPublicKey", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("isRevoked", TableInfo.Column("isRevoked", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppDeviceName", TableInfo.Column("ppDeviceName", "TEXT", true, 0, "''", TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppTimeCreated", TableInfo.Column("ppTimeCreated", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppAaguid", TableInfo.Column("ppAaguid", "TEXT", true, 0, "''", TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppProviderName", TableInfo.Column("ppProviderName", "TEXT", true, 0, "''", TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppIconLight", TableInfo.Column("ppIconLight", "TEXT", true, 0, "''", TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonPasskeyEntity.put("ppIconDark", TableInfo.Column("ppIconDark", "TEXT", true, 0, "''", TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysPersonPasskeyEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesPersonPasskeyEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoPersonPasskeyEntity: TableInfo = TableInfo("PersonPasskeyEntity", _columnsPersonPasskeyEntity, _foreignKeysPersonPasskeyEntity, _indicesPersonPasskeyEntity)
        val _existingPersonPasskeyEntity: TableInfo = read(connection, "PersonPasskeyEntity")
        if (!_infoPersonPasskeyEntity.equals(_existingPersonPasskeyEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |PersonPasskeyEntity(world.respect.datalayer.db.school.entities.PersonPasskeyEntity).
              | Expected:
              |""".trimMargin() + _infoPersonPasskeyEntity + """
              |
              | Found:
              |""".trimMargin() + _existingPersonPasskeyEntity)
        }
        val _columnsAuthTokenEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsAuthTokenEntity.put("atUid", TableInfo.Column("atUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAuthTokenEntity.put("atPGuidHash", TableInfo.Column("atPGuidHash", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAuthTokenEntity.put("atPGuid", TableInfo.Column("atPGuid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAuthTokenEntity.put("atCode", TableInfo.Column("atCode", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAuthTokenEntity.put("atToken", TableInfo.Column("atToken", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAuthTokenEntity.put("atTimeCreated", TableInfo.Column("atTimeCreated", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAuthTokenEntity.put("atTtl", TableInfo.Column("atTtl", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAuthTokenEntity.put("atPlatform", TableInfo.Column("atPlatform", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAuthTokenEntity.put("atAndroidSdkInt", TableInfo.Column("atAndroidSdkInt", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAuthTokenEntity.put("atVersion", TableInfo.Column("atVersion", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAuthTokenEntity.put("atManufacturer", TableInfo.Column("atManufacturer", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAuthTokenEntity.put("atModel", TableInfo.Column("atModel", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAuthTokenEntity.put("atRam", TableInfo.Column("atRam", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysAuthTokenEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesAuthTokenEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoAuthTokenEntity: TableInfo = TableInfo("AuthTokenEntity", _columnsAuthTokenEntity, _foreignKeysAuthTokenEntity, _indicesAuthTokenEntity)
        val _existingAuthTokenEntity: TableInfo = read(connection, "AuthTokenEntity")
        if (!_infoAuthTokenEntity.equals(_existingAuthTokenEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |AuthTokenEntity(world.respect.datalayer.db.school.entities.AuthTokenEntity).
              | Expected:
              |""".trimMargin() + _infoAuthTokenEntity + """
              |
              | Found:
              |""".trimMargin() + _existingAuthTokenEntity)
        }
        val _columnsReportEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsReportEntity.put("rGuid", TableInfo.Column("rGuid", "TEXT", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReportEntity.put("rOwnerGuid", TableInfo.Column("rOwnerGuid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReportEntity.put("rTitle", TableInfo.Column("rTitle", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReportEntity.put("rOptions", TableInfo.Column("rOptions", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReportEntity.put("rIsTemplate", TableInfo.Column("rIsTemplate", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReportEntity.put("rActive", TableInfo.Column("rActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReportEntity.put("rLastModified", TableInfo.Column("rLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReportEntity.put("rStored", TableInfo.Column("rStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysReportEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesReportEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoReportEntity: TableInfo = TableInfo("ReportEntity", _columnsReportEntity, _foreignKeysReportEntity, _indicesReportEntity)
        val _existingReportEntity: TableInfo = read(connection, "ReportEntity")
        if (!_infoReportEntity.equals(_existingReportEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |ReportEntity(world.respect.datalayer.db.school.entities.ReportEntity).
              | Expected:
              |""".trimMargin() + _infoReportEntity + """
              |
              | Found:
              |""".trimMargin() + _existingReportEntity)
        }
        val _columnsIndicatorEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsIndicatorEntity.put("indicatorId", TableInfo.Column("indicatorId", "TEXT", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsIndicatorEntity.put("name", TableInfo.Column("name", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsIndicatorEntity.put("description", TableInfo.Column("description", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsIndicatorEntity.put("type", TableInfo.Column("type", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsIndicatorEntity.put("sql", TableInfo.Column("sql", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysIndicatorEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesIndicatorEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoIndicatorEntity: TableInfo = TableInfo("IndicatorEntity", _columnsIndicatorEntity, _foreignKeysIndicatorEntity, _indicesIndicatorEntity)
        val _existingIndicatorEntity: TableInfo = read(connection, "IndicatorEntity")
        if (!_infoIndicatorEntity.equals(_existingIndicatorEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |IndicatorEntity(world.respect.datalayer.db.realm.entities.IndicatorEntity).
              | Expected:
              |""".trimMargin() + _infoIndicatorEntity + """
              |
              | Found:
              |""".trimMargin() + _existingIndicatorEntity)
        }
        val _columnsClassEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsClassEntity.put("cGuid", TableInfo.Column("cGuid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsClassEntity.put("cGuidHash", TableInfo.Column("cGuidHash", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsClassEntity.put("cTitle", TableInfo.Column("cTitle", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsClassEntity.put("cStatus", TableInfo.Column("cStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsClassEntity.put("cDescription", TableInfo.Column("cDescription", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsClassEntity.put("cLastModified", TableInfo.Column("cLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsClassEntity.put("cStored", TableInfo.Column("cStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsClassEntity.put("cTeacherInviteGuid", TableInfo.Column("cTeacherInviteGuid", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsClassEntity.put("cStudentInviteGuid", TableInfo.Column("cStudentInviteGuid", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysClassEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesClassEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoClassEntity: TableInfo = TableInfo("ClassEntity", _columnsClassEntity, _foreignKeysClassEntity, _indicesClassEntity)
        val _existingClassEntity: TableInfo = read(connection, "ClassEntity")
        if (!_infoClassEntity.equals(_existingClassEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |ClassEntity(world.respect.datalayer.db.school.entities.ClassEntity).
              | Expected:
              |""".trimMargin() + _infoClassEntity + """
              |
              | Found:
              |""".trimMargin() + _existingClassEntity)
        }
        val _columnsClassPermissionEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsClassPermissionEntity.put("cpeId", TableInfo.Column("cpeId", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsClassPermissionEntity.put("cpeClassUidNum", TableInfo.Column("cpeClassUidNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsClassPermissionEntity.put("cpeToEnrollmentRole", TableInfo.Column("cpeToEnrollmentRole", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsClassPermissionEntity.put("cpePermissions", TableInfo.Column("cpePermissions", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysClassPermissionEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesClassPermissionEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoClassPermissionEntity: TableInfo = TableInfo("ClassPermissionEntity", _columnsClassPermissionEntity, _foreignKeysClassPermissionEntity, _indicesClassPermissionEntity)
        val _existingClassPermissionEntity: TableInfo = read(connection, "ClassPermissionEntity")
        if (!_infoClassPermissionEntity.equals(_existingClassPermissionEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |ClassPermissionEntity(world.respect.datalayer.db.school.entities.ClassPermissionEntity).
              | Expected:
              |""".trimMargin() + _infoClassPermissionEntity + """
              |
              | Found:
              |""".trimMargin() + _existingClassPermissionEntity)
        }
        val _columnsEnrollmentEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsEnrollmentEntity.put("eUid", TableInfo.Column("eUid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eUidNum", TableInfo.Column("eUidNum", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eStatus", TableInfo.Column("eStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eLastModified", TableInfo.Column("eLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eStored", TableInfo.Column("eStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eMetadata", TableInfo.Column("eMetadata", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eClassUid", TableInfo.Column("eClassUid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eClassUidNum", TableInfo.Column("eClassUidNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("ePersonUid", TableInfo.Column("ePersonUid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("ePersonUidNum", TableInfo.Column("ePersonUidNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eRole", TableInfo.Column("eRole", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eBeginDate", TableInfo.Column("eBeginDate", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eEndDate", TableInfo.Column("eEndDate", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eRemovedAt", TableInfo.Column("eRemovedAt", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eInviteCode", TableInfo.Column("eInviteCode", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eApprovedByPersonUidNum", TableInfo.Column("eApprovedByPersonUidNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsEnrollmentEntity.put("eApprovedByPersonUid", TableInfo.Column("eApprovedByPersonUid", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysEnrollmentEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesEnrollmentEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoEnrollmentEntity: TableInfo = TableInfo("EnrollmentEntity", _columnsEnrollmentEntity, _foreignKeysEnrollmentEntity, _indicesEnrollmentEntity)
        val _existingEnrollmentEntity: TableInfo = read(connection, "EnrollmentEntity")
        if (!_infoEnrollmentEntity.equals(_existingEnrollmentEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |EnrollmentEntity(world.respect.datalayer.db.school.entities.EnrollmentEntity).
              | Expected:
              |""".trimMargin() + _infoEnrollmentEntity + """
              |
              | Found:
              |""".trimMargin() + _existingEnrollmentEntity)
        }
        val _columnsAssignmentEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsAssignmentEntity.put("aeUid", TableInfo.Column("aeUid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAssignmentEntity.put("aeUidNum", TableInfo.Column("aeUidNum", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAssignmentEntity.put("aeTitle", TableInfo.Column("aeTitle", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAssignmentEntity.put("aeDescription", TableInfo.Column("aeDescription", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAssignmentEntity.put("aeClassUid", TableInfo.Column("aeClassUid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAssignmentEntity.put("aeClassUidNum", TableInfo.Column("aeClassUidNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAssignmentEntity.put("aeDeadline", TableInfo.Column("aeDeadline", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAssignmentEntity.put("aeLastModified", TableInfo.Column("aeLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAssignmentEntity.put("aeStored", TableInfo.Column("aeStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysAssignmentEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesAssignmentEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoAssignmentEntity: TableInfo = TableInfo("AssignmentEntity", _columnsAssignmentEntity, _foreignKeysAssignmentEntity, _indicesAssignmentEntity)
        val _existingAssignmentEntity: TableInfo = read(connection, "AssignmentEntity")
        if (!_infoAssignmentEntity.equals(_existingAssignmentEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |AssignmentEntity(world.respect.datalayer.db.school.entities.AssignmentEntity).
              | Expected:
              |""".trimMargin() + _infoAssignmentEntity + """
              |
              | Found:
              |""".trimMargin() + _existingAssignmentEntity)
        }
        val _columnsAssignmentLearningResourceRefEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsAssignmentLearningResourceRefEntity.put("alrrAeUidNum", TableInfo.Column("alrrAeUidNum", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAssignmentLearningResourceRefEntity.put("alrrLearningUnitManifestUrlHash", TableInfo.Column("alrrLearningUnitManifestUrlHash", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAssignmentLearningResourceRefEntity.put("alrrLearningUnitManifestUrl", TableInfo.Column("alrrLearningUnitManifestUrl", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsAssignmentLearningResourceRefEntity.put("alrrAppManifestUrl", TableInfo.Column("alrrAppManifestUrl", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysAssignmentLearningResourceRefEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesAssignmentLearningResourceRefEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoAssignmentLearningResourceRefEntity: TableInfo = TableInfo("AssignmentLearningResourceRefEntity", _columnsAssignmentLearningResourceRefEntity, _foreignKeysAssignmentLearningResourceRefEntity, _indicesAssignmentLearningResourceRefEntity)
        val _existingAssignmentLearningResourceRefEntity: TableInfo = read(connection, "AssignmentLearningResourceRefEntity")
        if (!_infoAssignmentLearningResourceRefEntity.equals(_existingAssignmentLearningResourceRefEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |AssignmentLearningResourceRefEntity(world.respect.datalayer.db.school.entities.AssignmentLearningResourceRefEntity).
              | Expected:
              |""".trimMargin() + _infoAssignmentLearningResourceRefEntity + """
              |
              | Found:
              |""".trimMargin() + _existingAssignmentLearningResourceRefEntity)
        }
        val _columnsWriteQueueItemEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsWriteQueueItemEntity.put("wqiQueueItemId", TableInfo.Column("wqiQueueItemId", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsWriteQueueItemEntity.put("wqiModel", TableInfo.Column("wqiModel", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsWriteQueueItemEntity.put("wqiUid", TableInfo.Column("wqiUid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsWriteQueueItemEntity.put("wqiTimeQueued", TableInfo.Column("wqiTimeQueued", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsWriteQueueItemEntity.put("wqiAttemptCount", TableInfo.Column("wqiAttemptCount", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsWriteQueueItemEntity.put("wqiTimeWritten", TableInfo.Column("wqiTimeWritten", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsWriteQueueItemEntity.put("wqiAccountGuid", TableInfo.Column("wqiAccountGuid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysWriteQueueItemEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesWriteQueueItemEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoWriteQueueItemEntity: TableInfo = TableInfo("WriteQueueItemEntity", _columnsWriteQueueItemEntity, _foreignKeysWriteQueueItemEntity, _indicesWriteQueueItemEntity)
        val _existingWriteQueueItemEntity: TableInfo = read(connection, "WriteQueueItemEntity")
        if (!_infoWriteQueueItemEntity.equals(_existingWriteQueueItemEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |WriteQueueItemEntity(world.respect.datalayer.db.school.entities.WriteQueueItemEntity).
              | Expected:
              |""".trimMargin() + _infoWriteQueueItemEntity + """
              |
              | Found:
              |""".trimMargin() + _existingWriteQueueItemEntity)
        }
        val _columnsSchoolPermissionGrantEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsSchoolPermissionGrantEntity.put("spgUid", TableInfo.Column("spgUid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsSchoolPermissionGrantEntity.put("spgUidNum", TableInfo.Column("spgUidNum", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsSchoolPermissionGrantEntity.put("spgStatusEnum", TableInfo.Column("spgStatusEnum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsSchoolPermissionGrantEntity.put("spgToRole", TableInfo.Column("spgToRole", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsSchoolPermissionGrantEntity.put("spgPermissions", TableInfo.Column("spgPermissions", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsSchoolPermissionGrantEntity.put("spgLastModified", TableInfo.Column("spgLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsSchoolPermissionGrantEntity.put("spgStored", TableInfo.Column("spgStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysSchoolPermissionGrantEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesSchoolPermissionGrantEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoSchoolPermissionGrantEntity: TableInfo = TableInfo("SchoolPermissionGrantEntity", _columnsSchoolPermissionGrantEntity, _foreignKeysSchoolPermissionGrantEntity, _indicesSchoolPermissionGrantEntity)
        val _existingSchoolPermissionGrantEntity: TableInfo = read(connection, "SchoolPermissionGrantEntity")
        if (!_infoSchoolPermissionGrantEntity.equals(_existingSchoolPermissionGrantEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |SchoolPermissionGrantEntity(world.respect.datalayer.db.school.entities.SchoolPermissionGrantEntity).
              | Expected:
              |""".trimMargin() + _infoSchoolPermissionGrantEntity + """
              |
              | Found:
              |""".trimMargin() + _existingSchoolPermissionGrantEntity)
        }
        val _columnsPullSyncStatusEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsPullSyncStatusEntity.put("pssAccountPersonUid", TableInfo.Column("pssAccountPersonUid", "TEXT", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPullSyncStatusEntity.put("pssAccountPersonUidNum", TableInfo.Column("pssAccountPersonUidNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPullSyncStatusEntity.put("pssTableId", TableInfo.Column("pssTableId", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPullSyncStatusEntity.put("pssLastConsistentThrough", TableInfo.Column("pssLastConsistentThrough", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPullSyncStatusEntity.put("pssPermissionsLastModified", TableInfo.Column("pssPermissionsLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysPullSyncStatusEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesPullSyncStatusEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoPullSyncStatusEntity: TableInfo = TableInfo("PullSyncStatusEntity", _columnsPullSyncStatusEntity, _foreignKeysPullSyncStatusEntity, _indicesPullSyncStatusEntity)
        val _existingPullSyncStatusEntity: TableInfo = read(connection, "PullSyncStatusEntity")
        if (!_infoPullSyncStatusEntity.equals(_existingPullSyncStatusEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |PullSyncStatusEntity(world.respect.datalayer.db.school.entities.PullSyncStatusEntity).
              | Expected:
              |""".trimMargin() + _infoPullSyncStatusEntity + """
              |
              | Found:
              |""".trimMargin() + _existingPullSyncStatusEntity)
        }
        val _columnsPersonQrBadgeEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsPersonQrBadgeEntity.put("pqrGuidNum", TableInfo.Column("pqrGuidNum", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonQrBadgeEntity.put("pqrGuid", TableInfo.Column("pqrGuid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonQrBadgeEntity.put("pqrLastModified", TableInfo.Column("pqrLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonQrBadgeEntity.put("pqrStored", TableInfo.Column("pqrStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonQrBadgeEntity.put("pqrQrCodeUrl", TableInfo.Column("pqrQrCodeUrl", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsPersonQrBadgeEntity.put("pqrStatus", TableInfo.Column("pqrStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysPersonQrBadgeEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesPersonQrBadgeEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        _indicesPersonQrBadgeEntity.add(TableInfo.Index("index_PersonQrBadgeEntity_pqrQrCodeUrl", false, listOf("pqrQrCodeUrl"), listOf("ASC")))
        val _infoPersonQrBadgeEntity: TableInfo = TableInfo("PersonQrBadgeEntity", _columnsPersonQrBadgeEntity, _foreignKeysPersonQrBadgeEntity, _indicesPersonQrBadgeEntity)
        val _existingPersonQrBadgeEntity: TableInfo = read(connection, "PersonQrBadgeEntity")
        if (!_infoPersonQrBadgeEntity.equals(_existingPersonQrBadgeEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |PersonQrBadgeEntity(world.respect.datalayer.db.school.entities.PersonQrBadgeEntity).
              | Expected:
              |""".trimMargin() + _infoPersonQrBadgeEntity + """
              |
              | Found:
              |""".trimMargin() + _existingPersonQrBadgeEntity)
        }
        val _columnsInviteEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsInviteEntity.put("iGuid", TableInfo.Column("iGuid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iGuidHash", TableInfo.Column("iGuidHash", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iCode", TableInfo.Column("iCode", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iApprovalRequiredAfter", TableInfo.Column("iApprovalRequiredAfter", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iLastModified", TableInfo.Column("iLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iStored", TableInfo.Column("iStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iStatus", TableInfo.Column("iStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iNewUserRole", TableInfo.Column("iNewUserRole", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iNewUserFirstInvite", TableInfo.Column("iNewUserFirstInvite", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iForFamilyOfGuid", TableInfo.Column("iForFamilyOfGuid", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iForFamilyOfGuidHash", TableInfo.Column("iForFamilyOfGuidHash", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iForClassGuid", TableInfo.Column("iForClassGuid", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iForClassName", TableInfo.Column("iForClassName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iInviteMode", TableInfo.Column("iInviteMode", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iSchoolName", TableInfo.Column("iSchoolName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iForClassGuidHash", TableInfo.Column("iForClassGuidHash", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsInviteEntity.put("iForClassRole", TableInfo.Column("iForClassRole", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysInviteEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesInviteEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoInviteEntity: TableInfo = TableInfo("InviteEntity", _columnsInviteEntity, _foreignKeysInviteEntity, _indicesInviteEntity)
        val _existingInviteEntity: TableInfo = read(connection, "InviteEntity")
        if (!_infoInviteEntity.equals(_existingInviteEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |InviteEntity(world.respect.datalayer.db.school.entities.InviteEntity).
              | Expected:
              |""".trimMargin() + _infoInviteEntity + """
              |
              | Found:
              |""".trimMargin() + _existingInviteEntity)
        }
        val _columnsLangMapEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsLangMapEntity.put("lmeId", TableInfo.Column("lmeId", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsLangMapEntity.put("lmeTopParentType", TableInfo.Column("lmeTopParentType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsLangMapEntity.put("lmeTopParentUid1", TableInfo.Column("lmeTopParentUid1", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsLangMapEntity.put("lmeTopParentUid2", TableInfo.Column("lmeTopParentUid2", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsLangMapEntity.put("lmePropType", TableInfo.Column("lmePropType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsLangMapEntity.put("lmePropFk", TableInfo.Column("lmePropFk", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsLangMapEntity.put("lmeLang", TableInfo.Column("lmeLang", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsLangMapEntity.put("lmeRegion", TableInfo.Column("lmeRegion", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsLangMapEntity.put("lmeValue", TableInfo.Column("lmeValue", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysLangMapEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesLangMapEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        _indicesLangMapEntity.add(TableInfo.Index("index_LangMapEntity_lmeTopParentType_lmeTopParentUid1_lmeTopParentUid2_lmePropType", false, listOf("lmeTopParentType", "lmeTopParentUid1", "lmeTopParentUid2", "lmePropType"), listOf("ASC", "ASC", "ASC", "ASC")))
        val _infoLangMapEntity: TableInfo = TableInfo("LangMapEntity", _columnsLangMapEntity, _foreignKeysLangMapEntity, _indicesLangMapEntity)
        val _existingLangMapEntity: TableInfo = read(connection, "LangMapEntity")
        if (!_infoLangMapEntity.equals(_existingLangMapEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |LangMapEntity(world.respect.datalayer.db.shared.entities.LangMapEntity).
              | Expected:
              |""".trimMargin() + _infoLangMapEntity + """
              |
              | Found:
              |""".trimMargin() + _existingLangMapEntity)
        }
        val _columnsReadiumLinkEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsReadiumLinkEntity.put("rleId", TableInfo.Column("rleId", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleOpdsParentType", TableInfo.Column("rleOpdsParentType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleOpdsParentUid", TableInfo.Column("rleOpdsParentUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rlePropType", TableInfo.Column("rlePropType", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rlePropFk", TableInfo.Column("rlePropFk", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleIndex", TableInfo.Column("rleIndex", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleHref", TableInfo.Column("rleHref", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleRel", TableInfo.Column("rleRel", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleType", TableInfo.Column("rleType", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleTitle", TableInfo.Column("rleTitle", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleTemplated", TableInfo.Column("rleTemplated", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleProperties", TableInfo.Column("rleProperties", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleHeight", TableInfo.Column("rleHeight", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleWidth", TableInfo.Column("rleWidth", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleSize", TableInfo.Column("rleSize", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleBitrate", TableInfo.Column("rleBitrate", "REAL", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleDuration", TableInfo.Column("rleDuration", "REAL", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumLinkEntity.put("rleLanguage", TableInfo.Column("rleLanguage", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysReadiumLinkEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesReadiumLinkEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoReadiumLinkEntity: TableInfo = TableInfo("ReadiumLinkEntity", _columnsReadiumLinkEntity, _foreignKeysReadiumLinkEntity, _indicesReadiumLinkEntity)
        val _existingReadiumLinkEntity: TableInfo = read(connection, "ReadiumLinkEntity")
        if (!_infoReadiumLinkEntity.equals(_existingReadiumLinkEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |ReadiumLinkEntity(world.respect.datalayer.db.school.opds.entities.ReadiumLinkEntity).
              | Expected:
              |""".trimMargin() + _infoReadiumLinkEntity + """
              |
              | Found:
              |""".trimMargin() + _existingReadiumLinkEntity)
        }
        val _columnsOpdsPublicationEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsOpdsPublicationEntity.put("opeUid", TableInfo.Column("opeUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsPublicationEntity.put("opeOfeUid", TableInfo.Column("opeOfeUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsPublicationEntity.put("opeOgeUid", TableInfo.Column("opeOgeUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsPublicationEntity.put("opeIndex", TableInfo.Column("opeIndex", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsPublicationEntity.put("opeUrl", TableInfo.Column("opeUrl", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsPublicationEntity.put("opeUrlHash", TableInfo.Column("opeUrlHash", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsPublicationEntity.put("opeLastModified", TableInfo.Column("opeLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsPublicationEntity.put("opeEtag", TableInfo.Column("opeEtag", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsPublicationEntity.put("opeMdIdentifier", TableInfo.Column("opeMdIdentifier", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsPublicationEntity.put("opeMdLanguage", TableInfo.Column("opeMdLanguage", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsPublicationEntity.put("opeMdType", TableInfo.Column("opeMdType", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsPublicationEntity.put("opeMdDescription", TableInfo.Column("opeMdDescription", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsPublicationEntity.put("opeMdNumberOfPages", TableInfo.Column("opeMdNumberOfPages", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsPublicationEntity.put("opeMdDuration", TableInfo.Column("opeMdDuration", "REAL", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysOpdsPublicationEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesOpdsPublicationEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoOpdsPublicationEntity: TableInfo = TableInfo("OpdsPublicationEntity", _columnsOpdsPublicationEntity, _foreignKeysOpdsPublicationEntity, _indicesOpdsPublicationEntity)
        val _existingOpdsPublicationEntity: TableInfo = read(connection, "OpdsPublicationEntity")
        if (!_infoOpdsPublicationEntity.equals(_existingOpdsPublicationEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |OpdsPublicationEntity(world.respect.datalayer.db.school.opds.entities.OpdsPublicationEntity).
              | Expected:
              |""".trimMargin() + _infoOpdsPublicationEntity + """
              |
              | Found:
              |""".trimMargin() + _existingOpdsPublicationEntity)
        }
        val _columnsReadiumSubjectEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsReadiumSubjectEntity.put("rseUid", TableInfo.Column("rseUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumSubjectEntity.put("rseStringValue", TableInfo.Column("rseStringValue", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumSubjectEntity.put("rseTopParentType", TableInfo.Column("rseTopParentType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumSubjectEntity.put("rseTopParentUid", TableInfo.Column("rseTopParentUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumSubjectEntity.put("rseSubjectSortAs", TableInfo.Column("rseSubjectSortAs", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumSubjectEntity.put("rseSubjectCode", TableInfo.Column("rseSubjectCode", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumSubjectEntity.put("rseSubjectScheme", TableInfo.Column("rseSubjectScheme", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsReadiumSubjectEntity.put("rseIndex", TableInfo.Column("rseIndex", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysReadiumSubjectEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesReadiumSubjectEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoReadiumSubjectEntity: TableInfo = TableInfo("ReadiumSubjectEntity", _columnsReadiumSubjectEntity, _foreignKeysReadiumSubjectEntity, _indicesReadiumSubjectEntity)
        val _existingReadiumSubjectEntity: TableInfo = read(connection, "ReadiumSubjectEntity")
        if (!_infoReadiumSubjectEntity.equals(_existingReadiumSubjectEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |ReadiumSubjectEntity(world.respect.datalayer.db.school.opds.entities.ReadiumSubjectEntity).
              | Expected:
              |""".trimMargin() + _infoReadiumSubjectEntity + """
              |
              | Found:
              |""".trimMargin() + _existingReadiumSubjectEntity)
        }
        val _columnsOpdsFacetEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsOpdsFacetEntity.put("ofaeUid", TableInfo.Column("ofaeUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFacetEntity.put("ofaeOfeUid", TableInfo.Column("ofaeOfeUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysOpdsFacetEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesOpdsFacetEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoOpdsFacetEntity: TableInfo = TableInfo("OpdsFacetEntity", _columnsOpdsFacetEntity, _foreignKeysOpdsFacetEntity, _indicesOpdsFacetEntity)
        val _existingOpdsFacetEntity: TableInfo = read(connection, "OpdsFacetEntity")
        if (!_infoOpdsFacetEntity.equals(_existingOpdsFacetEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |OpdsFacetEntity(world.respect.datalayer.db.school.opds.entities.OpdsFacetEntity).
              | Expected:
              |""".trimMargin() + _infoOpdsFacetEntity + """
              |
              | Found:
              |""".trimMargin() + _existingOpdsFacetEntity)
        }
        val _columnsOpdsGroupEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsOpdsGroupEntity.put("ogeUid", TableInfo.Column("ogeUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsGroupEntity.put("ogeOfeUid", TableInfo.Column("ogeOfeUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsGroupEntity.put("ogeIndex", TableInfo.Column("ogeIndex", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysOpdsGroupEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesOpdsGroupEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoOpdsGroupEntity: TableInfo = TableInfo("OpdsGroupEntity", _columnsOpdsGroupEntity, _foreignKeysOpdsGroupEntity, _indicesOpdsGroupEntity)
        val _existingOpdsGroupEntity: TableInfo = read(connection, "OpdsGroupEntity")
        if (!_infoOpdsGroupEntity.equals(_existingOpdsGroupEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |OpdsGroupEntity(world.respect.datalayer.db.school.opds.entities.OpdsGroupEntity).
              | Expected:
              |""".trimMargin() + _infoOpdsGroupEntity + """
              |
              | Found:
              |""".trimMargin() + _existingOpdsGroupEntity)
        }
        val _columnsOpdsFeedEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsOpdsFeedEntity.put("ofeUid", TableInfo.Column("ofeUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedEntity.put("ofeUrl", TableInfo.Column("ofeUrl", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedEntity.put("ofeUrlHash", TableInfo.Column("ofeUrlHash", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedEntity.put("ofeLastModified", TableInfo.Column("ofeLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedEntity.put("ofeLastModifiedHeader", TableInfo.Column("ofeLastModifiedHeader", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedEntity.put("ofeEtag", TableInfo.Column("ofeEtag", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedEntity.put("ofeStored", TableInfo.Column("ofeStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysOpdsFeedEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesOpdsFeedEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoOpdsFeedEntity: TableInfo = TableInfo("OpdsFeedEntity", _columnsOpdsFeedEntity, _foreignKeysOpdsFeedEntity, _indicesOpdsFeedEntity)
        val _existingOpdsFeedEntity: TableInfo = read(connection, "OpdsFeedEntity")
        if (!_infoOpdsFeedEntity.equals(_existingOpdsFeedEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |OpdsFeedEntity(world.respect.datalayer.db.school.opds.entities.OpdsFeedEntity).
              | Expected:
              |""".trimMargin() + _infoOpdsFeedEntity + """
              |
              | Found:
              |""".trimMargin() + _existingOpdsFeedEntity)
        }
        val _columnsOpdsFeedMetadataEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsOpdsFeedMetadataEntity.put("ofmeUid", TableInfo.Column("ofmeUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedMetadataEntity.put("ofmeOfeUid", TableInfo.Column("ofmeOfeUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedMetadataEntity.put("ofmePropType", TableInfo.Column("ofmePropType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedMetadataEntity.put("ofmePropFk", TableInfo.Column("ofmePropFk", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedMetadataEntity.put("ofmeIdentifier", TableInfo.Column("ofmeIdentifier", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedMetadataEntity.put("ofmeType", TableInfo.Column("ofmeType", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedMetadataEntity.put("ofmeTitle", TableInfo.Column("ofmeTitle", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedMetadataEntity.put("ofmeSubtitle", TableInfo.Column("ofmeSubtitle", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedMetadataEntity.put("ofmeModified", TableInfo.Column("ofmeModified", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedMetadataEntity.put("ofmeDescription", TableInfo.Column("ofmeDescription", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedMetadataEntity.put("ofmeItemsPerPage", TableInfo.Column("ofmeItemsPerPage", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedMetadataEntity.put("ofmeCurrentPage", TableInfo.Column("ofmeCurrentPage", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsOpdsFeedMetadataEntity.put("ofmeNumberOfItems", TableInfo.Column("ofmeNumberOfItems", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysOpdsFeedMetadataEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesOpdsFeedMetadataEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoOpdsFeedMetadataEntity: TableInfo = TableInfo("OpdsFeedMetadataEntity", _columnsOpdsFeedMetadataEntity, _foreignKeysOpdsFeedMetadataEntity, _indicesOpdsFeedMetadataEntity)
        val _existingOpdsFeedMetadataEntity: TableInfo = read(connection, "OpdsFeedMetadataEntity")
        if (!_infoOpdsFeedMetadataEntity.equals(_existingOpdsFeedMetadataEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |OpdsFeedMetadataEntity(world.respect.datalayer.db.school.opds.entities.OpdsFeedMetadataEntity).
              | Expected:
              |""".trimMargin() + _infoOpdsFeedMetadataEntity + """
              |
              | Found:
              |""".trimMargin() + _existingOpdsFeedMetadataEntity)
        }
        return RoomOpenDelegate.ValidationResult(true, null)
      }
    }
    return _openDelegate
  }

  protected override fun createInvalidationTracker(): InvalidationTracker {
    val _shadowTablesMap: MutableMap<String, String> = mutableMapOf()
    val _viewTables: MutableMap<String, Set<String>> = mutableMapOf()
    return InvalidationTracker(this, _shadowTablesMap, _viewTables, "SchoolAppEntity", "PersonEntity", "PersonRoleEntity", "PersonRelatedPersonEntity", "PersonPasswordEntity", "PersonPasskeyEntity", "AuthTokenEntity", "ReportEntity", "IndicatorEntity", "ClassEntity", "ClassPermissionEntity", "EnrollmentEntity", "AssignmentEntity", "AssignmentLearningResourceRefEntity", "WriteQueueItemEntity", "SchoolPermissionGrantEntity", "PullSyncStatusEntity", "PersonQrBadgeEntity", "InviteEntity", "LangMapEntity", "ReadiumLinkEntity", "OpdsPublicationEntity", "ReadiumSubjectEntity", "OpdsFacetEntity", "OpdsGroupEntity", "OpdsFeedEntity", "OpdsFeedMetadataEntity")
  }

  protected override fun getRequiredTypeConverterClasses(): Map<KClass<*>, List<KClass<*>>> {
    val _typeConvertersMap: MutableMap<KClass<*>, List<KClass<*>>> = mutableMapOf()
    _typeConvertersMap.put(SchoolAppEntityDao::class, SchoolAppEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(PersonEntityDao::class, PersonEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(PersonPasswordEntityDao::class, PersonPasswordEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(PersonQrBadgeEntityDao::class, PersonQrBadgeEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(PersonPasskeyEntityDao::class, PersonPasskeyEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(AuthTokenEntityDao::class, AuthTokenEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(PersonRoleEntityDao::class, PersonRoleEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(PersonRelatedPersonEntityDao::class, PersonRelatedPersonEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(ReportEntityDao::class, ReportEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(IndicatorEntityDao::class, IndicatorEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(ClassEntityDao::class, ClassEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(ClassPermissionEntityDao::class, ClassPermissionEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(EnrollmentEntityDao::class, EnrollmentEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(AssignmentEntityDao::class, AssignmentEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(AssignmentLearningResourceRefEntityDao::class, AssignmentLearningResourceRefEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(WriteQueueItemEntityDao::class, WriteQueueItemEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(InviteEntityDao::class, InviteEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(SchoolPermissionGrantDao::class, SchoolPermissionGrantDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(PullSyncStatusEntityDao::class, PullSyncStatusEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(LangMapEntityDao::class, LangMapEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(OpdsFeedEntityDao::class, OpdsFeedEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(OpdsPublicationEntityDao::class, OpdsPublicationEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(OpdsFeedMetadataEntityDao::class, OpdsFeedMetadataEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(ReadiumLinkEntityDao::class, ReadiumLinkEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(OpdsGroupEntityDao::class, OpdsGroupEntityDao_Impl.getRequiredConverters())
    return _typeConvertersMap
  }

  public override fun getRequiredAutoMigrationSpecClasses(): Set<KClass<out AutoMigrationSpec>> {
    val _autoMigrationSpecsSet: MutableSet<KClass<out AutoMigrationSpec>> = mutableSetOf()
    return _autoMigrationSpecsSet
  }

  public override fun createAutoMigrations(autoMigrationSpecs: Map<KClass<out AutoMigrationSpec>, AutoMigrationSpec>): List<Migration> {
    val _autoMigrations: MutableList<Migration> = mutableListOf()
    return _autoMigrations
  }

  public override fun getSchoolAppEntityDao(): SchoolAppEntityDao = _schoolAppEntityDao.value

  public override fun getPersonEntityDao(): PersonEntityDao = _personEntityDao.value

  public override fun getPersonPasswordEntityDao(): PersonPasswordEntityDao = _personPasswordEntityDao.value

  public override fun getPersonQrBadgeEntityDao(): PersonQrBadgeEntityDao = _personQrBadgeEntityDao.value

  public override fun getPersonPasskeyEntityDao(): PersonPasskeyEntityDao = _personPasskeyEntityDao.value

  public override fun getAuthTokenEntityDao(): AuthTokenEntityDao = _authTokenEntityDao.value

  public override fun getPersonRoleEntityDao(): PersonRoleEntityDao = _personRoleEntityDao.value

  public override fun getPersonRelatedPersonEntityDao(): PersonRelatedPersonEntityDao = _personRelatedPersonEntityDao.value

  public override fun getReportEntityDao(): ReportEntityDao = _reportEntityDao.value

  public override fun getIndicatorEntityDao(): IndicatorEntityDao = _indicatorEntityDao.value

  public override fun getClassEntityDao(): ClassEntityDao = _classEntityDao.value

  public override fun getClassPermissionEntityDao(): ClassPermissionEntityDao = _classPermissionEntityDao.value

  public override fun getEnrollmentEntityDao(): EnrollmentEntityDao = _enrollmentEntityDao.value

  public override fun getAssignmentEntityDao(): AssignmentEntityDao = _assignmentEntityDao.value

  public override fun getAssignmentLearningResourceRefEntityDao(): AssignmentLearningResourceRefEntityDao = _assignmentLearningResourceRefEntityDao.value

  public override fun getWriteQueueItemEntityDao(): WriteQueueItemEntityDao = _writeQueueItemEntityDao.value

  public override fun getInviteEntityDao(): InviteEntityDao = _inviteEntityDao.value

  public override fun getSchoolPermissionGrantDao(): SchoolPermissionGrantDao = _schoolPermissionGrantDao.value

  public override fun getPullSyncStatusEntityDao(): PullSyncStatusEntityDao = _pullSyncStatusEntityDao.value

  public override fun getLangMapEntityDao(): LangMapEntityDao = _langMapEntityDao.value

  public override fun getOpdsFeedEntityDao(): OpdsFeedEntityDao = _opdsFeedEntityDao.value

  public override fun getOpdsPublicationEntityDao(): OpdsPublicationEntityDao = _opdsPublicationEntityDao.value

  public override fun getOpdsFeedMetadataEntityDao(): OpdsFeedMetadataEntityDao = _opdsFeedMetadataEntityDao.value

  public override fun getReadiumLinkEntityDao(): ReadiumLinkEntityDao = _readiumLinkEntityDao.value

  public override fun getOpdsGroupEntityDao(): OpdsGroupEntityDao = _opdsGroupEntityDao.value
}
