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 com.ustadmobile.core.db.dao.xapi.XapiActivityLangMapEntryDao
import com.ustadmobile.core.db.dao.xapi.XapiActivityLangMapEntryDao_Impl
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.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.school.xapi.daos.XapiActivityEntityDao
import world.respect.datalayer.db.school.xapi.daos.XapiActivityEntityDao_Impl
import world.respect.datalayer.db.school.xapi.daos.XapiActivityExtensionDao
import world.respect.datalayer.db.school.xapi.daos.XapiActivityExtensionDao_Impl
import world.respect.datalayer.db.school.xapi.daos.XapiActivityInteractionDao
import world.respect.datalayer.db.school.xapi.daos.XapiActivityInteractionDao_Impl
import world.respect.datalayer.db.school.xapi.daos.XapiActorDao
import world.respect.datalayer.db.school.xapi.daos.XapiActorDao_Impl
import world.respect.datalayer.db.school.xapi.daos.XapiGroupMemberActorJoinDao
import world.respect.datalayer.db.school.xapi.daos.XapiGroupMemberActorJoinDao_Impl
import world.respect.datalayer.db.school.xapi.daos.XapiSessionEntityDao
import world.respect.datalayer.db.school.xapi.daos.XapiSessionEntityDao_Impl
import world.respect.datalayer.db.school.xapi.daos.XapiStatementContextActivityJoinDao
import world.respect.datalayer.db.school.xapi.daos.XapiStatementContextActivityJoinDao_Impl
import world.respect.datalayer.db.school.xapi.daos.XapiStatementEntityDao
import world.respect.datalayer.db.school.xapi.daos.XapiStatementEntityDao_Impl
import world.respect.datalayer.db.school.xapi.daos.XapiStatementEntityJsonDao
import world.respect.datalayer.db.school.xapi.daos.XapiStatementEntityJsonDao_Impl
import world.respect.datalayer.db.school.xapi.daos.XapiVerbDao
import world.respect.datalayer.db.school.xapi.daos.XapiVerbDao_Impl
import world.respect.datalayer.db.school.xapi.daos.XapiVerbLangMapEntryDao
import world.respect.datalayer.db.school.xapi.daos.XapiVerbLangMapEntryDao_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 _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)
  }

  private val _xapiActivityEntityDao: Lazy<XapiActivityEntityDao> = lazy {
    XapiActivityEntityDao_Impl(this)
  }

  private val _xapiActivityExtensionDao: Lazy<XapiActivityExtensionDao> = lazy {
    XapiActivityExtensionDao_Impl(this)
  }

  private val _xapiActivityInteractionDao: Lazy<XapiActivityInteractionDao> = lazy {
    XapiActivityInteractionDao_Impl(this)
  }

  private val _xapiActivityLangMapEntryDao: Lazy<XapiActivityLangMapEntryDao> = lazy {
    XapiActivityLangMapEntryDao_Impl(this)
  }

  private val _xapiStatementContextActivityJoinDao: Lazy<XapiStatementContextActivityJoinDao> =
      lazy {
    XapiStatementContextActivityJoinDao_Impl(this)
  }

  private val _xapiStatementEntityDao: Lazy<XapiStatementEntityDao> = lazy {
    XapiStatementEntityDao_Impl(this)
  }

  private val _xapiStatementEntityJsonDao: Lazy<XapiStatementEntityJsonDao> = lazy {
    XapiStatementEntityJsonDao_Impl(this)
  }

  private val _xapiActorDao: Lazy<XapiActorDao> = lazy {
    XapiActorDao_Impl(this)
  }

  private val _xapiGroupMemberActorJoinDao: Lazy<XapiGroupMemberActorJoinDao> = lazy {
    XapiGroupMemberActorJoinDao_Impl(this)
  }

  private val _xapiVerbDao: Lazy<XapiVerbDao> = lazy {
    XapiVerbDao_Impl(this)
  }

  private val _xapiVerbLangMapEntryDao: Lazy<XapiVerbLangMapEntryDao> = lazy {
    XapiVerbLangMapEntryDao_Impl(this)
  }

  private val _xapiSessionEntityDao: Lazy<XapiSessionEntityDao> = lazy {
    XapiSessionEntityDao_Impl(this)
  }

  protected override fun createOpenDelegate(): RoomOpenDelegate {
    val _openDelegate: RoomOpenDelegate = object : RoomOpenDelegate(15, "d0ce2cda1cbb3ce252ef8d27256ef03c", "e2f65c64fd01912bc8834a9db447d7f0") {
      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 `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 `XapiActivityEntity` (`actUid` INTEGER NOT NULL, `actIdIri` TEXT NOT NULL, `actType` TEXT, `actMoreInfo` TEXT, `actInteractionType` INTEGER, `actCorrectResponsePatterns` TEXT, `actNonSignificantLastModified` INTEGER NOT NULL, `actSignificantLastModified` INTEGER NOT NULL, `actStored` INTEGER NOT NULL, `actFlags` INTEGER NOT NULL, `actObjectTypeSet` INTEGER NOT NULL, PRIMARY KEY(`actUid`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `XapiActivityExtensionEntity` (`aeeActivityUid` INTEGER NOT NULL, `aeeKeyHash` INTEGER NOT NULL, `aeeKey` TEXT NOT NULL, `aeeJson` TEXT NOT NULL, `aeeLastMod` INTEGER NOT NULL, PRIMARY KEY(`aeeActivityUid`, `aeeKeyHash`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `XapiActivityInteractionEntity` (`aieUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `aieActivityUid` INTEGER NOT NULL, `aieProp` INTEGER NOT NULL, `aieId` TEXT NOT NULL)")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `index_XapiActivityInteractionEntity_aieActivityUid` ON `XapiActivityInteractionEntity` (`aieActivityUid`)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `XapiActivityLangMapEntry` (`almeActivityUid` INTEGER NOT NULL, `almeKeyHash` INTEGER NOT NULL, `almeProperty` INTEGER NOT NULL, `almeInteractionId` TEXT, `almeLangCode` TEXT NOT NULL, `almeValue` TEXT NOT NULL, `almeLastModified` INTEGER NOT NULL, PRIMARY KEY(`almeActivityUid`, `almeKeyHash`))")
        connection.execSQL("CREATE UNIQUE INDEX IF NOT EXISTS `index_XapiActivityLangMapEntry_almeActivityUid_almeProperty_almeInteractionId_almeLangCode` ON `XapiActivityLangMapEntry` (`almeActivityUid`, `almeProperty`, `almeInteractionId`, `almeLangCode`)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `XapiActorEntity` (`actorUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `actorPersonUid` INTEGER NOT NULL, `actorName` TEXT, `actorMbox` TEXT, `actorMbox_sha1sum` TEXT, `actorOpenid` TEXT, `actorAccountName` TEXT, `actorAccountHomePage` TEXT, `actorStored` INTEGER NOT NULL, `actorLastModified` INTEGER NOT NULL, `actorGroupMembersLastUpdated` INTEGER NOT NULL, `actorIsAnonGroup` INTEGER NOT NULL, `actorObjectType` INTEGER NOT NULL)")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `idx_actorentity_uid_personuid` ON `XapiActorEntity` (`actorPersonUid`)")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `idx_actorentity_actorobjecttype` ON `XapiActorEntity` (`actorObjectType`)")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `idx_actorentity_actorIsAnonGroup` ON `XapiActorEntity` (`actorIsAnonGroup`)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `XapiGroupMemberActorJoin` (`gmajGroupActorUid` INTEGER NOT NULL, `gmajMemberActorUid` INTEGER NOT NULL, PRIMARY KEY(`gmajGroupActorUid`, `gmajMemberActorUid`))")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `idx_groupmemberactorjoin_gmajgroupactoruid` ON `XapiGroupMemberActorJoin` (`gmajGroupActorUid`)")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `idx_groupmemberactorjoin_gmajmemberactoruid` ON `XapiGroupMemberActorJoin` (`gmajMemberActorUid`)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `XapiStatementContextActivityJoin` (`scajUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `scajFromStatementIdHi` INTEGER NOT NULL, `scajFromStatementIdLo` INTEGER NOT NULL, `scajContextType` INTEGER NOT NULL, `scajToActivityUid` INTEGER NOT NULL, `scajToActivityId` TEXT NOT NULL)")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `idx_statementctx_stmt_id` ON `XapiStatementContextActivityJoin` (`scajFromStatementIdHi`, `scajFromStatementIdLo`)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `XapiStatementEntity` (`statementIdHi` INTEGER NOT NULL, `statementIdLo` INTEGER NOT NULL, `statementVerbUid` INTEGER NOT NULL, `statementVerbId` TEXT NOT NULL, `statementObjectType` INTEGER NOT NULL, `statementObjectActivityId` TEXT, `statementObjectUid1` INTEGER NOT NULL, `statementObjectUid2` INTEGER NOT NULL, `statementActorUid` INTEGER NOT NULL, `authorityActorUid` INTEGER NOT NULL, `resultCompletion` INTEGER, `resultSuccess` INTEGER, `resultScoreScaled` REAL, `resultScoreRaw` REAL, `resultScoreMin` REAL, `resultScoreMax` REAL, `resultDuration` INTEGER, `resultResponse` TEXT, `resultExtensions` TEXT, `timestamp` INTEGER, `stored` INTEGER, `contextRegistrationHi` INTEGER NOT NULL, `contextRegistrationLo` INTEGER NOT NULL, `contextRegistrationHash` INTEGER NOT NULL, `contextLanguage` TEXT, `contextPlatform` TEXT, `contextRevision` TEXT, `contextStatementRefIdHi` INTEGER NOT NULL, `contextStatementRefIdLo` INTEGER NOT NULL, `contextInstructorActorUid` INTEGER NOT NULL, `contextTeamActorUid` INTEGER NOT NULL, `extensionProgress` INTEGER, `completionOrProgress` INTEGER NOT NULL, `isSubStatement` INTEGER NOT NULL, `statementVersion` TEXT, `stmtVoid` INTEGER NOT NULL, PRIMARY KEY(`statementIdHi`, `statementIdLo`))")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `idx_stmt_stored` ON `XapiStatementEntity` (`stored`)")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `idx_stmt_actor` ON `XapiStatementEntity` (`statementActorUid`)")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `idx_stmt_verb` ON `XapiStatementEntity` (`statementVerbUid`)")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `idx_stmt_obj1` ON `XapiStatementEntity` (`statementObjectUid1`)")
        connection.execSQL("CREATE INDEX IF NOT EXISTS `idx_stmt_since` ON `XapiStatementEntity` (`stored`)")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `XapiStatementEntityJson` (`stmtJsonIdHi` INTEGER NOT NULL, `stmtJsonIdLo` INTEGER NOT NULL, `fullStatement` TEXT NOT NULL, PRIMARY KEY(`stmtJsonIdHi`, `stmtJsonIdLo`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `XapiVerbEntity` (`verbUid` INTEGER NOT NULL, `verbUrlId` TEXT NOT NULL, `verbStatus` INTEGER NOT NULL, `verbLct` INTEGER NOT NULL, PRIMARY KEY(`verbUid`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `XapiVerbLangMapEntry` (`vlmeVerbUid` INTEGER NOT NULL, `vlmeLangCode` TEXT NOT NULL, `vlmeEntryString` TEXT NOT NULL, PRIMARY KEY(`vlmeVerbUid`, `vlmeLangCode`))")
        connection.execSQL("CREATE TABLE IF NOT EXISTS `XapiSessionEntity` (`xseUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `xseRegistrationHi` INTEGER NOT NULL, `xseRegistrationLo` INTEGER NOT NULL, `xseAccountPersonUid` TEXT NOT NULL, `xseActorUid` INTEGER NOT NULL, `xseStartTime` INTEGER NOT NULL, `xseExpireTime` INTEGER NOT NULL, `xseAuth` TEXT NOT NULL)")
        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, 'd0ce2cda1cbb3ce252ef8d27256ef03c')")
      }

      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 `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`")
        connection.execSQL("DROP TABLE IF EXISTS `XapiActivityEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `XapiActivityExtensionEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `XapiActivityInteractionEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `XapiActivityLangMapEntry`")
        connection.execSQL("DROP TABLE IF EXISTS `XapiActorEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `XapiGroupMemberActorJoin`")
        connection.execSQL("DROP TABLE IF EXISTS `XapiStatementContextActivityJoin`")
        connection.execSQL("DROP TABLE IF EXISTS `XapiStatementEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `XapiStatementEntityJson`")
        connection.execSQL("DROP TABLE IF EXISTS `XapiVerbEntity`")
        connection.execSQL("DROP TABLE IF EXISTS `XapiVerbLangMapEntry`")
        connection.execSQL("DROP TABLE IF EXISTS `XapiSessionEntity`")
      }

      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 _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)
        }
        val _columnsXapiActivityEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsXapiActivityEntity.put("actUid", TableInfo.Column("actUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityEntity.put("actIdIri", TableInfo.Column("actIdIri", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityEntity.put("actType", TableInfo.Column("actType", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityEntity.put("actMoreInfo", TableInfo.Column("actMoreInfo", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityEntity.put("actInteractionType", TableInfo.Column("actInteractionType", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityEntity.put("actCorrectResponsePatterns", TableInfo.Column("actCorrectResponsePatterns", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityEntity.put("actNonSignificantLastModified", TableInfo.Column("actNonSignificantLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityEntity.put("actSignificantLastModified", TableInfo.Column("actSignificantLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityEntity.put("actStored", TableInfo.Column("actStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityEntity.put("actFlags", TableInfo.Column("actFlags", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityEntity.put("actObjectTypeSet", TableInfo.Column("actObjectTypeSet", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysXapiActivityEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesXapiActivityEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoXapiActivityEntity: TableInfo = TableInfo("XapiActivityEntity", _columnsXapiActivityEntity, _foreignKeysXapiActivityEntity, _indicesXapiActivityEntity)
        val _existingXapiActivityEntity: TableInfo = read(connection, "XapiActivityEntity")
        if (!_infoXapiActivityEntity.equals(_existingXapiActivityEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |XapiActivityEntity(world.respect.datalayer.db.school.xapi.entities.XapiActivityEntity).
              | Expected:
              |""".trimMargin() + _infoXapiActivityEntity + """
              |
              | Found:
              |""".trimMargin() + _existingXapiActivityEntity)
        }
        val _columnsXapiActivityExtensionEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsXapiActivityExtensionEntity.put("aeeActivityUid", TableInfo.Column("aeeActivityUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityExtensionEntity.put("aeeKeyHash", TableInfo.Column("aeeKeyHash", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityExtensionEntity.put("aeeKey", TableInfo.Column("aeeKey", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityExtensionEntity.put("aeeJson", TableInfo.Column("aeeJson", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityExtensionEntity.put("aeeLastMod", TableInfo.Column("aeeLastMod", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysXapiActivityExtensionEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesXapiActivityExtensionEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoXapiActivityExtensionEntity: TableInfo = TableInfo("XapiActivityExtensionEntity", _columnsXapiActivityExtensionEntity, _foreignKeysXapiActivityExtensionEntity, _indicesXapiActivityExtensionEntity)
        val _existingXapiActivityExtensionEntity: TableInfo = read(connection, "XapiActivityExtensionEntity")
        if (!_infoXapiActivityExtensionEntity.equals(_existingXapiActivityExtensionEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |XapiActivityExtensionEntity(world.respect.datalayer.db.school.xapi.entities.XapiActivityExtensionEntity).
              | Expected:
              |""".trimMargin() + _infoXapiActivityExtensionEntity + """
              |
              | Found:
              |""".trimMargin() + _existingXapiActivityExtensionEntity)
        }
        val _columnsXapiActivityInteractionEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsXapiActivityInteractionEntity.put("aieUid", TableInfo.Column("aieUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityInteractionEntity.put("aieActivityUid", TableInfo.Column("aieActivityUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityInteractionEntity.put("aieProp", TableInfo.Column("aieProp", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityInteractionEntity.put("aieId", TableInfo.Column("aieId", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysXapiActivityInteractionEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesXapiActivityInteractionEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        _indicesXapiActivityInteractionEntity.add(TableInfo.Index("index_XapiActivityInteractionEntity_aieActivityUid", false, listOf("aieActivityUid"), listOf("ASC")))
        val _infoXapiActivityInteractionEntity: TableInfo = TableInfo("XapiActivityInteractionEntity", _columnsXapiActivityInteractionEntity, _foreignKeysXapiActivityInteractionEntity, _indicesXapiActivityInteractionEntity)
        val _existingXapiActivityInteractionEntity: TableInfo = read(connection, "XapiActivityInteractionEntity")
        if (!_infoXapiActivityInteractionEntity.equals(_existingXapiActivityInteractionEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |XapiActivityInteractionEntity(world.respect.datalayer.db.school.xapi.entities.XapiActivityInteractionEntity).
              | Expected:
              |""".trimMargin() + _infoXapiActivityInteractionEntity + """
              |
              | Found:
              |""".trimMargin() + _existingXapiActivityInteractionEntity)
        }
        val _columnsXapiActivityLangMapEntry: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsXapiActivityLangMapEntry.put("almeActivityUid", TableInfo.Column("almeActivityUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityLangMapEntry.put("almeKeyHash", TableInfo.Column("almeKeyHash", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityLangMapEntry.put("almeProperty", TableInfo.Column("almeProperty", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityLangMapEntry.put("almeInteractionId", TableInfo.Column("almeInteractionId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityLangMapEntry.put("almeLangCode", TableInfo.Column("almeLangCode", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityLangMapEntry.put("almeValue", TableInfo.Column("almeValue", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActivityLangMapEntry.put("almeLastModified", TableInfo.Column("almeLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysXapiActivityLangMapEntry: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesXapiActivityLangMapEntry: MutableSet<TableInfo.Index> = mutableSetOf()
        _indicesXapiActivityLangMapEntry.add(TableInfo.Index("index_XapiActivityLangMapEntry_almeActivityUid_almeProperty_almeInteractionId_almeLangCode", true, listOf("almeActivityUid", "almeProperty", "almeInteractionId", "almeLangCode"), listOf("ASC", "ASC", "ASC", "ASC")))
        val _infoXapiActivityLangMapEntry: TableInfo = TableInfo("XapiActivityLangMapEntry", _columnsXapiActivityLangMapEntry, _foreignKeysXapiActivityLangMapEntry, _indicesXapiActivityLangMapEntry)
        val _existingXapiActivityLangMapEntry: TableInfo = read(connection, "XapiActivityLangMapEntry")
        if (!_infoXapiActivityLangMapEntry.equals(_existingXapiActivityLangMapEntry)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |XapiActivityLangMapEntry(world.respect.datalayer.db.school.xapi.entities.XapiActivityLangMapEntry).
              | Expected:
              |""".trimMargin() + _infoXapiActivityLangMapEntry + """
              |
              | Found:
              |""".trimMargin() + _existingXapiActivityLangMapEntry)
        }
        val _columnsXapiActorEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsXapiActorEntity.put("actorUid", TableInfo.Column("actorUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActorEntity.put("actorPersonUid", TableInfo.Column("actorPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActorEntity.put("actorName", TableInfo.Column("actorName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActorEntity.put("actorMbox", TableInfo.Column("actorMbox", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActorEntity.put("actorMbox_sha1sum", TableInfo.Column("actorMbox_sha1sum", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActorEntity.put("actorOpenid", TableInfo.Column("actorOpenid", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActorEntity.put("actorAccountName", TableInfo.Column("actorAccountName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActorEntity.put("actorAccountHomePage", TableInfo.Column("actorAccountHomePage", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActorEntity.put("actorStored", TableInfo.Column("actorStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActorEntity.put("actorLastModified", TableInfo.Column("actorLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActorEntity.put("actorGroupMembersLastUpdated", TableInfo.Column("actorGroupMembersLastUpdated", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActorEntity.put("actorIsAnonGroup", TableInfo.Column("actorIsAnonGroup", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiActorEntity.put("actorObjectType", TableInfo.Column("actorObjectType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysXapiActorEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesXapiActorEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        _indicesXapiActorEntity.add(TableInfo.Index("idx_actorentity_uid_personuid", false, listOf("actorPersonUid"), listOf("ASC")))
        _indicesXapiActorEntity.add(TableInfo.Index("idx_actorentity_actorobjecttype", false, listOf("actorObjectType"), listOf("ASC")))
        _indicesXapiActorEntity.add(TableInfo.Index("idx_actorentity_actorIsAnonGroup", false, listOf("actorIsAnonGroup"), listOf("ASC")))
        val _infoXapiActorEntity: TableInfo = TableInfo("XapiActorEntity", _columnsXapiActorEntity, _foreignKeysXapiActorEntity, _indicesXapiActorEntity)
        val _existingXapiActorEntity: TableInfo = read(connection, "XapiActorEntity")
        if (!_infoXapiActorEntity.equals(_existingXapiActorEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |XapiActorEntity(world.respect.datalayer.db.school.xapi.entities.XapiActorEntity).
              | Expected:
              |""".trimMargin() + _infoXapiActorEntity + """
              |
              | Found:
              |""".trimMargin() + _existingXapiActorEntity)
        }
        val _columnsXapiGroupMemberActorJoin: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsXapiGroupMemberActorJoin.put("gmajGroupActorUid", TableInfo.Column("gmajGroupActorUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiGroupMemberActorJoin.put("gmajMemberActorUid", TableInfo.Column("gmajMemberActorUid", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysXapiGroupMemberActorJoin: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesXapiGroupMemberActorJoin: MutableSet<TableInfo.Index> = mutableSetOf()
        _indicesXapiGroupMemberActorJoin.add(TableInfo.Index("idx_groupmemberactorjoin_gmajgroupactoruid", false, listOf("gmajGroupActorUid"), listOf("ASC")))
        _indicesXapiGroupMemberActorJoin.add(TableInfo.Index("idx_groupmemberactorjoin_gmajmemberactoruid", false, listOf("gmajMemberActorUid"), listOf("ASC")))
        val _infoXapiGroupMemberActorJoin: TableInfo = TableInfo("XapiGroupMemberActorJoin", _columnsXapiGroupMemberActorJoin, _foreignKeysXapiGroupMemberActorJoin, _indicesXapiGroupMemberActorJoin)
        val _existingXapiGroupMemberActorJoin: TableInfo = read(connection, "XapiGroupMemberActorJoin")
        if (!_infoXapiGroupMemberActorJoin.equals(_existingXapiGroupMemberActorJoin)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |XapiGroupMemberActorJoin(world.respect.datalayer.db.school.xapi.entities.XapiGroupMemberActorJoin).
              | Expected:
              |""".trimMargin() + _infoXapiGroupMemberActorJoin + """
              |
              | Found:
              |""".trimMargin() + _existingXapiGroupMemberActorJoin)
        }
        val _columnsXapiStatementContextActivityJoin: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsXapiStatementContextActivityJoin.put("scajUid", TableInfo.Column("scajUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementContextActivityJoin.put("scajFromStatementIdHi", TableInfo.Column("scajFromStatementIdHi", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementContextActivityJoin.put("scajFromStatementIdLo", TableInfo.Column("scajFromStatementIdLo", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementContextActivityJoin.put("scajContextType", TableInfo.Column("scajContextType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementContextActivityJoin.put("scajToActivityUid", TableInfo.Column("scajToActivityUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementContextActivityJoin.put("scajToActivityId", TableInfo.Column("scajToActivityId", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysXapiStatementContextActivityJoin: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesXapiStatementContextActivityJoin: MutableSet<TableInfo.Index> = mutableSetOf()
        _indicesXapiStatementContextActivityJoin.add(TableInfo.Index("idx_statementctx_stmt_id", false, listOf("scajFromStatementIdHi", "scajFromStatementIdLo"), listOf("ASC", "ASC")))
        val _infoXapiStatementContextActivityJoin: TableInfo = TableInfo("XapiStatementContextActivityJoin", _columnsXapiStatementContextActivityJoin, _foreignKeysXapiStatementContextActivityJoin, _indicesXapiStatementContextActivityJoin)
        val _existingXapiStatementContextActivityJoin: TableInfo = read(connection, "XapiStatementContextActivityJoin")
        if (!_infoXapiStatementContextActivityJoin.equals(_existingXapiStatementContextActivityJoin)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |XapiStatementContextActivityJoin(world.respect.datalayer.db.school.xapi.entities.XapiStatementContextActivityJoin).
              | Expected:
              |""".trimMargin() + _infoXapiStatementContextActivityJoin + """
              |
              | Found:
              |""".trimMargin() + _existingXapiStatementContextActivityJoin)
        }
        val _columnsXapiStatementEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsXapiStatementEntity.put("statementIdHi", TableInfo.Column("statementIdHi", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("statementIdLo", TableInfo.Column("statementIdLo", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("statementVerbUid", TableInfo.Column("statementVerbUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("statementVerbId", TableInfo.Column("statementVerbId", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("statementObjectType", TableInfo.Column("statementObjectType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("statementObjectActivityId", TableInfo.Column("statementObjectActivityId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("statementObjectUid1", TableInfo.Column("statementObjectUid1", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("statementObjectUid2", TableInfo.Column("statementObjectUid2", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("statementActorUid", TableInfo.Column("statementActorUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("authorityActorUid", TableInfo.Column("authorityActorUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("resultCompletion", TableInfo.Column("resultCompletion", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("resultSuccess", TableInfo.Column("resultSuccess", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("resultScoreScaled", TableInfo.Column("resultScoreScaled", "REAL", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("resultScoreRaw", TableInfo.Column("resultScoreRaw", "REAL", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("resultScoreMin", TableInfo.Column("resultScoreMin", "REAL", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("resultScoreMax", TableInfo.Column("resultScoreMax", "REAL", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("resultDuration", TableInfo.Column("resultDuration", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("resultResponse", TableInfo.Column("resultResponse", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("resultExtensions", TableInfo.Column("resultExtensions", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("timestamp", TableInfo.Column("timestamp", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("stored", TableInfo.Column("stored", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("contextRegistrationHi", TableInfo.Column("contextRegistrationHi", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("contextRegistrationLo", TableInfo.Column("contextRegistrationLo", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("contextRegistrationHash", TableInfo.Column("contextRegistrationHash", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("contextLanguage", TableInfo.Column("contextLanguage", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("contextPlatform", TableInfo.Column("contextPlatform", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("contextRevision", TableInfo.Column("contextRevision", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("contextStatementRefIdHi", TableInfo.Column("contextStatementRefIdHi", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("contextStatementRefIdLo", TableInfo.Column("contextStatementRefIdLo", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("contextInstructorActorUid", TableInfo.Column("contextInstructorActorUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("contextTeamActorUid", TableInfo.Column("contextTeamActorUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("extensionProgress", TableInfo.Column("extensionProgress", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("completionOrProgress", TableInfo.Column("completionOrProgress", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("isSubStatement", TableInfo.Column("isSubStatement", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("statementVersion", TableInfo.Column("statementVersion", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntity.put("stmtVoid", TableInfo.Column("stmtVoid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysXapiStatementEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesXapiStatementEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        _indicesXapiStatementEntity.add(TableInfo.Index("idx_stmt_stored", false, listOf("stored"), listOf("ASC")))
        _indicesXapiStatementEntity.add(TableInfo.Index("idx_stmt_actor", false, listOf("statementActorUid"), listOf("ASC")))
        _indicesXapiStatementEntity.add(TableInfo.Index("idx_stmt_verb", false, listOf("statementVerbUid"), listOf("ASC")))
        _indicesXapiStatementEntity.add(TableInfo.Index("idx_stmt_obj1", false, listOf("statementObjectUid1"), listOf("ASC")))
        _indicesXapiStatementEntity.add(TableInfo.Index("idx_stmt_since", false, listOf("stored"), listOf("ASC")))
        val _infoXapiStatementEntity: TableInfo = TableInfo("XapiStatementEntity", _columnsXapiStatementEntity, _foreignKeysXapiStatementEntity, _indicesXapiStatementEntity)
        val _existingXapiStatementEntity: TableInfo = read(connection, "XapiStatementEntity")
        if (!_infoXapiStatementEntity.equals(_existingXapiStatementEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |XapiStatementEntity(world.respect.datalayer.db.school.xapi.entities.XapiStatementEntity).
              | Expected:
              |""".trimMargin() + _infoXapiStatementEntity + """
              |
              | Found:
              |""".trimMargin() + _existingXapiStatementEntity)
        }
        val _columnsXapiStatementEntityJson: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsXapiStatementEntityJson.put("stmtJsonIdHi", TableInfo.Column("stmtJsonIdHi", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntityJson.put("stmtJsonIdLo", TableInfo.Column("stmtJsonIdLo", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiStatementEntityJson.put("fullStatement", TableInfo.Column("fullStatement", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysXapiStatementEntityJson: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesXapiStatementEntityJson: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoXapiStatementEntityJson: TableInfo = TableInfo("XapiStatementEntityJson", _columnsXapiStatementEntityJson, _foreignKeysXapiStatementEntityJson, _indicesXapiStatementEntityJson)
        val _existingXapiStatementEntityJson: TableInfo = read(connection, "XapiStatementEntityJson")
        if (!_infoXapiStatementEntityJson.equals(_existingXapiStatementEntityJson)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |XapiStatementEntityJson(world.respect.datalayer.db.school.xapi.entities.XapiStatementEntityJson).
              | Expected:
              |""".trimMargin() + _infoXapiStatementEntityJson + """
              |
              | Found:
              |""".trimMargin() + _existingXapiStatementEntityJson)
        }
        val _columnsXapiVerbEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsXapiVerbEntity.put("verbUid", TableInfo.Column("verbUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiVerbEntity.put("verbUrlId", TableInfo.Column("verbUrlId", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiVerbEntity.put("verbStatus", TableInfo.Column("verbStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiVerbEntity.put("verbLct", TableInfo.Column("verbLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysXapiVerbEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesXapiVerbEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoXapiVerbEntity: TableInfo = TableInfo("XapiVerbEntity", _columnsXapiVerbEntity, _foreignKeysXapiVerbEntity, _indicesXapiVerbEntity)
        val _existingXapiVerbEntity: TableInfo = read(connection, "XapiVerbEntity")
        if (!_infoXapiVerbEntity.equals(_existingXapiVerbEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |XapiVerbEntity(world.respect.datalayer.db.school.xapi.entities.XapiVerbEntity).
              | Expected:
              |""".trimMargin() + _infoXapiVerbEntity + """
              |
              | Found:
              |""".trimMargin() + _existingXapiVerbEntity)
        }
        val _columnsXapiVerbLangMapEntry: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsXapiVerbLangMapEntry.put("vlmeVerbUid", TableInfo.Column("vlmeVerbUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiVerbLangMapEntry.put("vlmeLangCode", TableInfo.Column("vlmeLangCode", "TEXT", true, 2, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiVerbLangMapEntry.put("vlmeEntryString", TableInfo.Column("vlmeEntryString", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysXapiVerbLangMapEntry: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesXapiVerbLangMapEntry: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoXapiVerbLangMapEntry: TableInfo = TableInfo("XapiVerbLangMapEntry", _columnsXapiVerbLangMapEntry, _foreignKeysXapiVerbLangMapEntry, _indicesXapiVerbLangMapEntry)
        val _existingXapiVerbLangMapEntry: TableInfo = read(connection, "XapiVerbLangMapEntry")
        if (!_infoXapiVerbLangMapEntry.equals(_existingXapiVerbLangMapEntry)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |XapiVerbLangMapEntry(world.respect.datalayer.db.school.xapi.entities.XapiVerbLangMapEntry).
              | Expected:
              |""".trimMargin() + _infoXapiVerbLangMapEntry + """
              |
              | Found:
              |""".trimMargin() + _existingXapiVerbLangMapEntry)
        }
        val _columnsXapiSessionEntity: MutableMap<String, TableInfo.Column> = mutableMapOf()
        _columnsXapiSessionEntity.put("xseUid", TableInfo.Column("xseUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiSessionEntity.put("xseRegistrationHi", TableInfo.Column("xseRegistrationHi", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiSessionEntity.put("xseRegistrationLo", TableInfo.Column("xseRegistrationLo", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiSessionEntity.put("xseAccountPersonUid", TableInfo.Column("xseAccountPersonUid", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiSessionEntity.put("xseActorUid", TableInfo.Column("xseActorUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiSessionEntity.put("xseStartTime", TableInfo.Column("xseStartTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiSessionEntity.put("xseExpireTime", TableInfo.Column("xseExpireTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        _columnsXapiSessionEntity.put("xseAuth", TableInfo.Column("xseAuth", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
        val _foreignKeysXapiSessionEntity: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
        val _indicesXapiSessionEntity: MutableSet<TableInfo.Index> = mutableSetOf()
        val _infoXapiSessionEntity: TableInfo = TableInfo("XapiSessionEntity", _columnsXapiSessionEntity, _foreignKeysXapiSessionEntity, _indicesXapiSessionEntity)
        val _existingXapiSessionEntity: TableInfo = read(connection, "XapiSessionEntity")
        if (!_infoXapiSessionEntity.equals(_existingXapiSessionEntity)) {
          return RoomOpenDelegate.ValidationResult(false, """
              |XapiSessionEntity(world.respect.datalayer.db.school.xapi.entities.XapiSessionEntity).
              | Expected:
              |""".trimMargin() + _infoXapiSessionEntity + """
              |
              | Found:
              |""".trimMargin() + _existingXapiSessionEntity)
        }
        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", "WriteQueueItemEntity", "SchoolPermissionGrantEntity", "PullSyncStatusEntity", "PersonQrBadgeEntity", "InviteEntity", "LangMapEntity", "ReadiumLinkEntity", "OpdsPublicationEntity", "ReadiumSubjectEntity", "OpdsFacetEntity", "OpdsGroupEntity", "OpdsFeedEntity", "OpdsFeedMetadataEntity", "XapiActivityEntity", "XapiActivityExtensionEntity", "XapiActivityInteractionEntity", "XapiActivityLangMapEntry", "XapiActorEntity", "XapiGroupMemberActorJoin", "XapiStatementContextActivityJoin", "XapiStatementEntity", "XapiStatementEntityJson", "XapiVerbEntity", "XapiVerbLangMapEntry", "XapiSessionEntity")
  }

  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(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())
    _typeConvertersMap.put(XapiActivityEntityDao::class, XapiActivityEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(XapiActivityExtensionDao::class, XapiActivityExtensionDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(XapiActivityInteractionDao::class, XapiActivityInteractionDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(XapiActivityLangMapEntryDao::class, XapiActivityLangMapEntryDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(XapiStatementContextActivityJoinDao::class, XapiStatementContextActivityJoinDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(XapiStatementEntityDao::class, XapiStatementEntityDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(XapiStatementEntityJsonDao::class, XapiStatementEntityJsonDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(XapiActorDao::class, XapiActorDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(XapiGroupMemberActorJoinDao::class, XapiGroupMemberActorJoinDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(XapiVerbDao::class, XapiVerbDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(XapiVerbLangMapEntryDao::class, XapiVerbLangMapEntryDao_Impl.getRequiredConverters())
    _typeConvertersMap.put(XapiSessionEntityDao::class, XapiSessionEntityDao_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 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

  public override fun getActivityEntityDao(): XapiActivityEntityDao = _xapiActivityEntityDao.value

  public override fun getActivityExtensionDao(): XapiActivityExtensionDao = _xapiActivityExtensionDao.value

  public override fun getActivityInteractionDao(): XapiActivityInteractionDao = _xapiActivityInteractionDao.value

  public override fun getActivityLangMapEntryDao(): XapiActivityLangMapEntryDao = _xapiActivityLangMapEntryDao.value

  public override fun getStatementContextActivityJoinDao(): XapiStatementContextActivityJoinDao = _xapiStatementContextActivityJoinDao.value

  public override fun getStatementDao(): XapiStatementEntityDao = _xapiStatementEntityDao.value

  public override fun getStatementEntityJsonDao(): XapiStatementEntityJsonDao = _xapiStatementEntityJsonDao.value

  public override fun getActorDao(): XapiActorDao = _xapiActorDao.value

  public override fun getGroupMemberActorJoinDao(): XapiGroupMemberActorJoinDao = _xapiGroupMemberActorJoinDao.value

  public override fun getVerbDao(): XapiVerbDao = _xapiVerbDao.value

  public override fun getVerbLangMapEntryDao(): XapiVerbLangMapEntryDao = _xapiVerbLangMapEntryDao.value

  public override fun getXapiSessionEntityDao(): XapiSessionEntityDao = _xapiSessionEntityDao.value
}
