package com.ustadmobile.core.db;

import androidx.annotation.NonNull;
import androidx.room.DatabaseConfiguration;
import androidx.room.InvalidationTracker;
import androidx.room.RoomDatabase;
import androidx.room.RoomOpenHelper;
import androidx.room.migration.AutoMigrationSpec;
import androidx.room.migration.Migration;
import androidx.room.util.DBUtil;
import androidx.room.util.TableInfo;
import androidx.sqlite.db.SupportSQLiteDatabase;
import androidx.sqlite.db.SupportSQLiteOpenHelper;
import com.ustadmobile.core.db.dao.CacheLockJoinDao;
import com.ustadmobile.core.db.dao.CacheLockJoinDao_Impl;
import com.ustadmobile.core.db.dao.ClazzAssignmentDao;
import com.ustadmobile.core.db.dao.ClazzAssignmentDao_Impl;
import com.ustadmobile.core.db.dao.ClazzDao;
import com.ustadmobile.core.db.dao.ClazzDao_Impl;
import com.ustadmobile.core.db.dao.ClazzEnrolmentDao;
import com.ustadmobile.core.db.dao.ClazzEnrolmentDao_Impl;
import com.ustadmobile.core.db.dao.ClazzInviteDao;
import com.ustadmobile.core.db.dao.ClazzInviteDao_Impl;
import com.ustadmobile.core.db.dao.ClazzLogAttendanceRecordDao;
import com.ustadmobile.core.db.dao.ClazzLogAttendanceRecordDao_Impl;
import com.ustadmobile.core.db.dao.ClazzLogDao;
import com.ustadmobile.core.db.dao.ClazzLogDao_Impl;
import com.ustadmobile.core.db.dao.CommentsDao;
import com.ustadmobile.core.db.dao.CommentsDao_Impl;
import com.ustadmobile.core.db.dao.ContentCategoryDao;
import com.ustadmobile.core.db.dao.ContentCategoryDao_Impl;
import com.ustadmobile.core.db.dao.ContentCategorySchemaDao;
import com.ustadmobile.core.db.dao.ContentCategorySchemaDao_Impl;
import com.ustadmobile.core.db.dao.ContentEntryContentCategoryJoinDao;
import com.ustadmobile.core.db.dao.ContentEntryContentCategoryJoinDao_Impl;
import com.ustadmobile.core.db.dao.ContentEntryDao;
import com.ustadmobile.core.db.dao.ContentEntryDao_Impl;
import com.ustadmobile.core.db.dao.ContentEntryImportJobDao;
import com.ustadmobile.core.db.dao.ContentEntryImportJobDao_Impl;
import com.ustadmobile.core.db.dao.ContentEntryParentChildJoinDao;
import com.ustadmobile.core.db.dao.ContentEntryParentChildJoinDao_Impl;
import com.ustadmobile.core.db.dao.ContentEntryPicture2Dao;
import com.ustadmobile.core.db.dao.ContentEntryPicture2Dao_Impl;
import com.ustadmobile.core.db.dao.ContentEntryPictureDao;
import com.ustadmobile.core.db.dao.ContentEntryPictureDao_Impl;
import com.ustadmobile.core.db.dao.ContentEntryRelatedEntryJoinDao;
import com.ustadmobile.core.db.dao.ContentEntryRelatedEntryJoinDao_Impl;
import com.ustadmobile.core.db.dao.ContentEntryVersionDao;
import com.ustadmobile.core.db.dao.ContentEntryVersionDao_Impl;
import com.ustadmobile.core.db.dao.CourseAssignmentMarkDao;
import com.ustadmobile.core.db.dao.CourseAssignmentMarkDao_Impl;
import com.ustadmobile.core.db.dao.CourseAssignmentSubmissionDao;
import com.ustadmobile.core.db.dao.CourseAssignmentSubmissionDao_Impl;
import com.ustadmobile.core.db.dao.CourseAssignmentSubmissionFileDao;
import com.ustadmobile.core.db.dao.CourseAssignmentSubmissionFileDao_Impl;
import com.ustadmobile.core.db.dao.CourseBlockDao;
import com.ustadmobile.core.db.dao.CourseBlockDao_Impl;
import com.ustadmobile.core.db.dao.CourseBlockPictureDao;
import com.ustadmobile.core.db.dao.CourseBlockPictureDao_Impl;
import com.ustadmobile.core.db.dao.CourseGroupMemberDao;
import com.ustadmobile.core.db.dao.CourseGroupMemberDao_Impl;
import com.ustadmobile.core.db.dao.CourseGroupSetDao;
import com.ustadmobile.core.db.dao.CourseGroupSetDao_Impl;
import com.ustadmobile.core.db.dao.CoursePermissionDao;
import com.ustadmobile.core.db.dao.CoursePermissionDao_Impl;
import com.ustadmobile.core.db.dao.CoursePictureDao;
import com.ustadmobile.core.db.dao.CoursePictureDao_Impl;
import com.ustadmobile.core.db.dao.CourseTerminologyDao;
import com.ustadmobile.core.db.dao.CourseTerminologyDao_Impl;
import com.ustadmobile.core.db.dao.DeletedItemDao;
import com.ustadmobile.core.db.dao.DeletedItemDao_Impl;
import com.ustadmobile.core.db.dao.DiscussionPostDao;
import com.ustadmobile.core.db.dao.DiscussionPostDao_Impl;
import com.ustadmobile.core.db.dao.EnrolmentRequestDao;
import com.ustadmobile.core.db.dao.EnrolmentRequestDao_Impl;
import com.ustadmobile.core.db.dao.ErrorReportDao;
import com.ustadmobile.core.db.dao.ErrorReportDao_Impl;
import com.ustadmobile.core.db.dao.ExternalAppPermissionDao;
import com.ustadmobile.core.db.dao.ExternalAppPermissionDao_Impl;
import com.ustadmobile.core.db.dao.HolidayCalendarDao;
import com.ustadmobile.core.db.dao.HolidayCalendarDao_Impl;
import com.ustadmobile.core.db.dao.HolidayDao;
import com.ustadmobile.core.db.dao.HolidayDao_Impl;
import com.ustadmobile.core.db.dao.LanguageDao;
import com.ustadmobile.core.db.dao.LanguageDao_Impl;
import com.ustadmobile.core.db.dao.LanguageVariantDao;
import com.ustadmobile.core.db.dao.LanguageVariantDao_Impl;
import com.ustadmobile.core.db.dao.LeavingReasonDao;
import com.ustadmobile.core.db.dao.LeavingReasonDao_Impl;
import com.ustadmobile.core.db.dao.MessageDao;
import com.ustadmobile.core.db.dao.MessageDao_Impl;
import com.ustadmobile.core.db.dao.OfflineItemDao;
import com.ustadmobile.core.db.dao.OfflineItemDao_Impl;
import com.ustadmobile.core.db.dao.OutgoingReplicationDao;
import com.ustadmobile.core.db.dao.OutgoingReplicationDao_Impl;
import com.ustadmobile.core.db.dao.PeerReviewerAllocationDao;
import com.ustadmobile.core.db.dao.PeerReviewerAllocationDao_Impl;
import com.ustadmobile.core.db.dao.PersonAuth2Dao;
import com.ustadmobile.core.db.dao.PersonAuth2Dao_Impl;
import com.ustadmobile.core.db.dao.PersonAuthDao;
import com.ustadmobile.core.db.dao.PersonAuthDao_Impl;
import com.ustadmobile.core.db.dao.PersonDao;
import com.ustadmobile.core.db.dao.PersonDao_Impl;
import com.ustadmobile.core.db.dao.PersonGroupDao;
import com.ustadmobile.core.db.dao.PersonGroupDao_Impl;
import com.ustadmobile.core.db.dao.PersonGroupMemberDao;
import com.ustadmobile.core.db.dao.PersonGroupMemberDao_Impl;
import com.ustadmobile.core.db.dao.PersonParentJoinDao;
import com.ustadmobile.core.db.dao.PersonParentJoinDao_Impl;
import com.ustadmobile.core.db.dao.PersonPasskeyDao;
import com.ustadmobile.core.db.dao.PersonPasskeyDao_Impl;
import com.ustadmobile.core.db.dao.PersonPictureDao;
import com.ustadmobile.core.db.dao.PersonPictureDao_Impl;
import com.ustadmobile.core.db.dao.ReportDao;
import com.ustadmobile.core.db.dao.ReportDao_Impl;
import com.ustadmobile.core.db.dao.ScheduleDao;
import com.ustadmobile.core.db.dao.ScheduleDao_Impl;
import com.ustadmobile.core.db.dao.ScopedGrantDao;
import com.ustadmobile.core.db.dao.ScopedGrantDao_Impl;
import com.ustadmobile.core.db.dao.SiteDao;
import com.ustadmobile.core.db.dao.SiteDao_Impl;
import com.ustadmobile.core.db.dao.SiteTermsDao;
import com.ustadmobile.core.db.dao.SiteTermsDao_Impl;
import com.ustadmobile.core.db.dao.StudentResultDao;
import com.ustadmobile.core.db.dao.StudentResultDao_Impl;
import com.ustadmobile.core.db.dao.SyncNodeDao;
import com.ustadmobile.core.db.dao.SyncNodeDao_Impl;
import com.ustadmobile.core.db.dao.SystemPermissionDao;
import com.ustadmobile.core.db.dao.SystemPermissionDao_Impl;
import com.ustadmobile.core.db.dao.TransferJobDao;
import com.ustadmobile.core.db.dao.TransferJobDao_Impl;
import com.ustadmobile.core.db.dao.TransferJobErrorDao;
import com.ustadmobile.core.db.dao.TransferJobErrorDao_Impl;
import com.ustadmobile.core.db.dao.TransferJobItemDao;
import com.ustadmobile.core.db.dao.TransferJobItemDao_Impl;
import com.ustadmobile.core.db.dao.UserSessionDao;
import com.ustadmobile.core.db.dao.UserSessionDao_Impl;
import com.ustadmobile.core.db.dao.xapi.ActivityEntityDao;
import com.ustadmobile.core.db.dao.xapi.ActivityEntityDao_Impl;
import com.ustadmobile.core.db.dao.xapi.ActivityExtensionDao;
import com.ustadmobile.core.db.dao.xapi.ActivityExtensionDao_Impl;
import com.ustadmobile.core.db.dao.xapi.ActivityInteractionDao;
import com.ustadmobile.core.db.dao.xapi.ActivityInteractionDao_Impl;
import com.ustadmobile.core.db.dao.xapi.ActivityLangMapEntryDao;
import com.ustadmobile.core.db.dao.xapi.ActivityLangMapEntryDao_Impl;
import com.ustadmobile.core.db.dao.xapi.ActorDao;
import com.ustadmobile.core.db.dao.xapi.ActorDao_Impl;
import com.ustadmobile.core.db.dao.xapi.GroupMemberActorJoinDao;
import com.ustadmobile.core.db.dao.xapi.GroupMemberActorJoinDao_Impl;
import com.ustadmobile.core.db.dao.xapi.StateDeleteCommandDao;
import com.ustadmobile.core.db.dao.xapi.StateDeleteCommandDao_Impl;
import com.ustadmobile.core.db.dao.xapi.StateEntityDao;
import com.ustadmobile.core.db.dao.xapi.StateEntityDao_Impl;
import com.ustadmobile.core.db.dao.xapi.StatementContextActivityJoinDao;
import com.ustadmobile.core.db.dao.xapi.StatementContextActivityJoinDao_Impl;
import com.ustadmobile.core.db.dao.xapi.StatementDao;
import com.ustadmobile.core.db.dao.xapi.StatementDao_Impl;
import com.ustadmobile.core.db.dao.xapi.StatementEntityJsonDao;
import com.ustadmobile.core.db.dao.xapi.StatementEntityJsonDao_Impl;
import com.ustadmobile.core.db.dao.xapi.VerbDao;
import com.ustadmobile.core.db.dao.xapi.VerbDao_Impl;
import com.ustadmobile.core.db.dao.xapi.VerbLangMapEntryDao;
import com.ustadmobile.core.db.dao.xapi.VerbLangMapEntryDao_Impl;
import com.ustadmobile.core.db.dao.xapi.XapiSessionEntityDao;
import com.ustadmobile.core.db.dao.xapi.XapiSessionEntityDao_Impl;
import java.lang.Class;
import java.lang.Override;
import java.lang.String;
import java.lang.SuppressWarnings;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.processing.Generated;

@Generated("androidx.room.RoomProcessor")
@SuppressWarnings({"unchecked", "deprecation"})
public final class UmAppDatabase_Impl extends UmAppDatabase {
  private volatile PersonDao _personDao;

  private volatile ClazzDao _clazzDao;

  private volatile CourseBlockDao _courseBlockDao;

  private volatile CourseTerminologyDao _courseTerminologyDao;

  private volatile CourseGroupSetDao _courseGroupSetDao;

  private volatile CourseGroupMemberDao _courseGroupMemberDao;

  private volatile ClazzEnrolmentDao _clazzEnrolmentDao;

  private volatile LeavingReasonDao _leavingReasonDao;

  private volatile ContentEntryDao _contentEntryDao;

  private volatile ContentEntryContentCategoryJoinDao _contentEntryContentCategoryJoinDao;

  private volatile ContentEntryParentChildJoinDao _contentEntryParentChildJoinDao;

  private volatile ContentEntryRelatedEntryJoinDao _contentEntryRelatedEntryJoinDao;

  private volatile ContentCategorySchemaDao _contentCategorySchemaDao;

  private volatile ContentCategoryDao _contentCategoryDao;

  private volatile LanguageDao _languageDao;

  private volatile LanguageVariantDao _languageVariantDao;

  private volatile PersonAuthDao _personAuthDao;

  private volatile PersonGroupDao _personGroupDao;

  private volatile PersonGroupMemberDao _personGroupMemberDao;

  private volatile PersonPictureDao _personPictureDao;

  private volatile VerbDao _verbDao;

  private volatile ActivityEntityDao _activityEntityDao;

  private volatile ReportDao _reportDao;

  private volatile StatementDao _statementDao;

  private volatile ActorDao _actorDao;

  private volatile ClazzLogAttendanceRecordDao _clazzLogAttendanceRecordDao;

  private volatile ClazzLogDao _clazzLogDao;

  private volatile ScheduleDao _scheduleDao;

  private volatile HolidayCalendarDao _holidayCalendarDao;

  private volatile HolidayDao _holidayDao;

  private volatile ClazzAssignmentDao _clazzAssignmentDao;

  private volatile CourseAssignmentSubmissionDao _courseAssignmentSubmissionDao;

  private volatile CourseAssignmentSubmissionFileDao _courseAssignmentSubmissionFileDao;

  private volatile CourseAssignmentMarkDao _courseAssignmentMarkDao;

  private volatile CommentsDao _commentsDao;

  private volatile SyncNodeDao _syncNodeDao;

  private volatile SiteDao _siteDao;

  private volatile SiteTermsDao _siteTermsDao;

  private volatile PersonParentJoinDao _personParentJoinDao;

  private volatile ScopedGrantDao _scopedGrantDao;

  private volatile ErrorReportDao _errorReportDao;

  private volatile PersonAuth2Dao _personAuth2Dao;

  private volatile UserSessionDao _userSessionDao;

  private volatile ContentEntryImportJobDao _contentEntryImportJobDao;

  private volatile CoursePictureDao _coursePictureDao;

  private volatile ContentEntryPictureDao _contentEntryPictureDao;

  private volatile MessageDao _messageDao;

  private volatile PeerReviewerAllocationDao _peerReviewerAllocationDao;

  private volatile DiscussionPostDao _discussionPostDao;

  private volatile ExternalAppPermissionDao _externalAppPermissionDao;

  private volatile ContentEntryVersionDao _contentEntryVersionDao;

  private volatile OutgoingReplicationDao _outgoingReplicationDao;

  private volatile TransferJobDao _transferJobDao;

  private volatile TransferJobItemDao _transferJobItemDao;

  private volatile CacheLockJoinDao _cacheLockJoinDao;

  private volatile OfflineItemDao _offlineItemDao;

  private volatile DeletedItemDao _deletedItemDao;

  private volatile EnrolmentRequestDao _enrolmentRequestDao;

  private volatile CoursePermissionDao _coursePermissionDao;

  private volatile SystemPermissionDao _systemPermissionDao;

  private volatile CourseBlockPictureDao _courseBlockPictureDao;

  private volatile ContentEntryPicture2Dao _contentEntryPicture2Dao;

  private volatile TransferJobErrorDao _transferJobErrorDao;

  private volatile StudentResultDao _studentResultDao;

  private volatile VerbLangMapEntryDao _verbLangMapEntryDao;

  private volatile GroupMemberActorJoinDao _groupMemberActorJoinDao;

  private volatile ActivityLangMapEntryDao _activityLangMapEntryDao;

  private volatile ActivityInteractionDao _activityInteractionDao;

  private volatile ActivityExtensionDao _activityExtensionDao;

  private volatile StatementContextActivityJoinDao _statementContextActivityJoinDao;

  private volatile XapiSessionEntityDao _xapiSessionEntityDao;

  private volatile StatementEntityJsonDao _statementEntityJsonDao;

  private volatile PersonPasskeyDao _personPasskeyDao;

  private volatile StateEntityDao _stateEntityDao;

  private volatile StateDeleteCommandDao _stateDeleteCommandDao;

  private volatile ClazzInviteDao _clazzInviteDao;

  @Override
  @NonNull
  protected SupportSQLiteOpenHelper createOpenHelper(@NonNull final DatabaseConfiguration config) {
    final SupportSQLiteOpenHelper.Callback _openCallback = new RoomOpenHelper(config, new RoomOpenHelper.Delegate(207) {
      @Override
      public void createAllTables(@NonNull final SupportSQLiteDatabase db) {
        db.execSQL("CREATE TABLE IF NOT EXISTS `ClazzLog` (`clazzLogUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `clazzLogClazzUid` INTEGER NOT NULL, `logDate` INTEGER NOT NULL, `timeRecorded` INTEGER NOT NULL, `clazzLogDone` INTEGER NOT NULL, `cancellationNote` TEXT, `clazzLogCancelled` INTEGER NOT NULL, `clazzLogNumPresent` INTEGER NOT NULL, `clazzLogNumAbsent` INTEGER NOT NULL, `clazzLogNumPartial` INTEGER NOT NULL, `clazzLogScheduleUid` INTEGER NOT NULL, `clazzLogStatusFlag` INTEGER NOT NULL, `clazzLogMSQN` INTEGER NOT NULL, `clazzLogLCSN` INTEGER NOT NULL, `clazzLogLCB` INTEGER NOT NULL, `clazzLogLastChangedTime` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ClazzLogAttendanceRecord` (`clazzLogAttendanceRecordUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `clazzLogAttendanceRecordClazzLogUid` INTEGER NOT NULL, `clazzLogAttendanceRecordPersonUid` INTEGER NOT NULL, `attendanceStatus` INTEGER NOT NULL, `clazzLogAttendanceRecordMasterChangeSeqNum` INTEGER NOT NULL, `clazzLogAttendanceRecordLocalChangeSeqNum` INTEGER NOT NULL, `clazzLogAttendanceRecordLastChangedBy` INTEGER NOT NULL, `clazzLogAttendanceRecordLastChangedTime` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `Schedule` (`scheduleUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `sceduleStartTime` INTEGER NOT NULL, `scheduleEndTime` INTEGER NOT NULL, `scheduleDay` INTEGER NOT NULL, `scheduleMonth` INTEGER NOT NULL, `scheduleFrequency` INTEGER NOT NULL, `umCalendarUid` INTEGER NOT NULL, `scheduleClazzUid` INTEGER NOT NULL, `scheduleMasterChangeSeqNum` INTEGER NOT NULL, `scheduleLocalChangeSeqNum` INTEGER NOT NULL, `scheduleLastChangedBy` INTEGER NOT NULL, `scheduleLastChangedTime` INTEGER NOT NULL, `scheduleActive` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `HolidayCalendar` (`umCalendarUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `umCalendarName` TEXT, `umCalendarCategory` INTEGER NOT NULL, `umCalendarActive` INTEGER NOT NULL, `umCalendarMasterChangeSeqNum` INTEGER NOT NULL, `umCalendarLocalChangeSeqNum` INTEGER NOT NULL, `umCalendarLastChangedBy` INTEGER NOT NULL, `umCalendarLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `Holiday` (`holUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `holMasterCsn` INTEGER NOT NULL, `holLocalCsn` INTEGER NOT NULL, `holLastModBy` INTEGER NOT NULL, `holLct` INTEGER NOT NULL, `holActive` INTEGER NOT NULL, `holHolidayCalendarUid` INTEGER NOT NULL, `holStartTime` INTEGER NOT NULL, `holEndTime` INTEGER NOT NULL, `holName` TEXT)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `Person` (`personUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `username` TEXT, `firstNames` TEXT, `lastName` TEXT, `emailAddr` TEXT, `phoneNum` TEXT, `gender` INTEGER NOT NULL, `active` INTEGER NOT NULL, `isPersonalAccount` INTEGER NOT NULL, `dateOfBirth` INTEGER NOT NULL, `personAddress` TEXT, `personOrgId` TEXT, `personGroupUid` INTEGER NOT NULL, `personLct` INTEGER NOT NULL, `personCountry` TEXT, `personType` INTEGER NOT NULL DEFAULT 0, `personMasterChangeSeqNum` INTEGER NOT NULL, `personLocalChangeSeqNum` INTEGER NOT NULL, `personLastChangedBy` INTEGER NOT NULL, `admin` INTEGER NOT NULL, `personNotes` TEXT, `fatherName` TEXT, `fatherNumber` TEXT, `motherName` TEXT, `motherNum` TEXT)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `Clazz` (`clazzUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `clazzName` TEXT, `clazzDesc` TEXT, `attendanceAverage` REAL NOT NULL, `clazzHolidayUMCalendarUid` INTEGER NOT NULL, `clazzScheuleUMCalendarUid` INTEGER NOT NULL, `isClazzActive` INTEGER NOT NULL, `clazzLocationUid` INTEGER NOT NULL, `clazzStartTime` INTEGER NOT NULL, `clazzEndTime` INTEGER NOT NULL, `clazzFeatures` INTEGER NOT NULL, `clazzSchoolUid` INTEGER NOT NULL, `clazzEnrolmentPolicy` INTEGER NOT NULL DEFAULT 102, `clazzTerminologyUid` INTEGER NOT NULL DEFAULT 25966, `clazzMasterChangeSeqNum` INTEGER NOT NULL, `clazzLocalChangeSeqNum` INTEGER NOT NULL, `clazzLastChangedBy` INTEGER NOT NULL, `clazzLct` INTEGER NOT NULL, `clazzTimeZone` TEXT, `clazzStudentsPersonGroupUid` INTEGER NOT NULL, `clazzTeachersPersonGroupUid` INTEGER NOT NULL, `clazzPendingStudentsPersonGroupUid` INTEGER NOT NULL, `clazzParentsPersonGroupUid` INTEGER NOT NULL, `clazzCode` TEXT, `clazzOwnerPersonUid` INTEGER NOT NULL DEFAULT 0)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ClazzEnrolment` (`clazzEnrolmentUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `clazzEnrolmentPersonUid` INTEGER NOT NULL, `clazzEnrolmentClazzUid` INTEGER NOT NULL, `clazzEnrolmentDateJoined` INTEGER NOT NULL, `clazzEnrolmentDateLeft` INTEGER NOT NULL, `clazzEnrolmentRole` INTEGER NOT NULL, `clazzEnrolmentAttendancePercentage` REAL NOT NULL, `clazzEnrolmentActive` INTEGER NOT NULL, `clazzEnrolmentLeavingReasonUid` INTEGER NOT NULL, `clazzEnrolmentOutcome` INTEGER NOT NULL, `clazzEnrolmentLocalChangeSeqNum` INTEGER NOT NULL, `clazzEnrolmentMasterChangeSeqNum` INTEGER NOT NULL, `clazzEnrolmentLastChangedBy` INTEGER NOT NULL, `clazzEnrolmentLct` INTEGER NOT NULL, `clazzEnrolmentInviteUid` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_ClazzEnrolment_clazzEnrolmentPersonUid_clazzEnrolmentClazzUid` ON `ClazzEnrolment` (`clazzEnrolmentPersonUid`, `clazzEnrolmentClazzUid`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_ClazzEnrolment_clazzEnrolmentClazzUid_clazzEnrolmentPersonUid` ON `ClazzEnrolment` (`clazzEnrolmentClazzUid`, `clazzEnrolmentPersonUid`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_ClazzEnrolment_clazzEnrolmentClazzUid_clazzEnrolmentRole` ON `ClazzEnrolment` (`clazzEnrolmentClazzUid`, `clazzEnrolmentRole`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_ClazzEnrolment_clazzEnrolmentPersonUid` ON `ClazzEnrolment` (`clazzEnrolmentPersonUid`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_ClazzEnrolment_clazzEnrolmentClazzUid` ON `ClazzEnrolment` (`clazzEnrolmentClazzUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `LeavingReason` (`leavingReasonUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `leavingReasonTitle` TEXT, `leavingReasonMCSN` INTEGER NOT NULL, `leavingReasonCSN` INTEGER NOT NULL, `leavingReasonLCB` INTEGER NOT NULL, `leavingReasonLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ClazzInvite` (`ciUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `ciPersonUid` INTEGER NOT NULL, `ciRoleId` INTEGER NOT NULL, `ciClazzUid` INTEGER NOT NULL, `inviteType` INTEGER NOT NULL DEFAULT 1, `inviteContact` TEXT NOT NULL, `inviteToken` TEXT NOT NULL, `inviteStatus` INTEGER NOT NULL, `inviteExpire` INTEGER NOT NULL, `inviteLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ContentEntry` (`contentEntryUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `title` TEXT, `description` TEXT, `entryId` TEXT, `author` TEXT, `publisher` TEXT, `licenseType` INTEGER NOT NULL, `licenseName` TEXT, `licenseUrl` TEXT, `sourceUrl` TEXT, `thumbnailUrl` TEXT, `lastModified` INTEGER NOT NULL, `primaryLanguageUid` INTEGER NOT NULL, `languageVariantUid` INTEGER NOT NULL, `contentFlags` INTEGER NOT NULL, `leaf` INTEGER NOT NULL, `publik` INTEGER NOT NULL, `ceInactive` INTEGER NOT NULL, `completionCriteria` INTEGER NOT NULL, `minScore` INTEGER NOT NULL, `contentTypeFlag` INTEGER NOT NULL, `contentOwner` INTEGER NOT NULL, `contentOwnerType` INTEGER NOT NULL DEFAULT 1, `contentEntryLocalChangeSeqNum` INTEGER NOT NULL, `contentEntryMasterChangeSeqNum` INTEGER NOT NULL, `contentEntryLastChangedBy` INTEGER NOT NULL, `contentEntryLct` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_ContentEntry_primaryLanguageUid` ON `ContentEntry` (`primaryLanguageUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ContentEntryContentCategoryJoin` (`ceccjUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `ceccjContentEntryUid` INTEGER NOT NULL, `ceccjContentCategoryUid` INTEGER NOT NULL, `ceccjLocalChangeSeqNum` INTEGER NOT NULL, `ceccjMasterChangeSeqNum` INTEGER NOT NULL, `ceccjLastChangedBy` INTEGER NOT NULL, `ceccjLct` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_ContentEntryContentCategoryJoin_ceccjContentEntryUid` ON `ContentEntryContentCategoryJoin` (`ceccjContentEntryUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ContentEntryParentChildJoin` (`cepcjParentContentEntryUid` INTEGER NOT NULL, `cepcjChildContentEntryUid` INTEGER NOT NULL, `childIndex` INTEGER NOT NULL, `cepcjUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `cepcjLocalChangeSeqNum` INTEGER NOT NULL, `cepcjMasterChangeSeqNum` INTEGER NOT NULL, `cepcjLastChangedBy` INTEGER NOT NULL, `cepcjLct` INTEGER NOT NULL, `cepcjDeleted` INTEGER NOT NULL DEFAULT 0)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `parent_child` ON `ContentEntryParentChildJoin` (`cepcjChildContentEntryUid`, `cepcjParentContentEntryUid`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_ContentEntryParentChildJoin_cepcjParentContentEntryUid` ON `ContentEntryParentChildJoin` (`cepcjParentContentEntryUid`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_ContentEntryParentChildJoin_cepcjChildContentEntryUid` ON `ContentEntryParentChildJoin` (`cepcjChildContentEntryUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ContentEntryRelatedEntryJoin` (`cerejUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `cerejContentEntryUid` INTEGER NOT NULL, `cerejRelatedEntryUid` INTEGER NOT NULL, `cerejLastChangedBy` INTEGER NOT NULL, `relType` INTEGER NOT NULL, `comment` TEXT, `cerejRelLanguageUid` INTEGER NOT NULL, `cerejLocalChangeSeqNum` INTEGER NOT NULL, `cerejMasterChangeSeqNum` INTEGER NOT NULL, `cerejLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ContentCategorySchema` (`contentCategorySchemaUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `schemaName` TEXT, `schemaUrl` TEXT, `contentCategorySchemaLocalChangeSeqNum` INTEGER NOT NULL, `contentCategorySchemaMasterChangeSeqNum` INTEGER NOT NULL, `contentCategorySchemaLastChangedBy` INTEGER NOT NULL, `contentCategorySchemaLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ContentCategory` (`contentCategoryUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `ctnCatContentCategorySchemaUid` INTEGER NOT NULL, `name` TEXT, `contentCategoryLocalChangeSeqNum` INTEGER NOT NULL, `contentCategoryMasterChangeSeqNum` INTEGER NOT NULL, `contentCategoryLastChangedBy` INTEGER NOT NULL, `contentCategoryLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `Language` (`langUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT, `iso_639_1_standard` TEXT, `iso_639_2_standard` TEXT, `iso_639_3_standard` TEXT, `Language_Type` TEXT, `languageActive` INTEGER NOT NULL, `langLocalChangeSeqNum` INTEGER NOT NULL, `langMasterChangeSeqNum` INTEGER NOT NULL, `langLastChangedBy` INTEGER NOT NULL, `langLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `LanguageVariant` (`langVariantUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `langUid` INTEGER NOT NULL, `countryCode` TEXT, `name` TEXT, `langVariantLocalChangeSeqNum` INTEGER NOT NULL, `langVariantMasterChangeSeqNum` INTEGER NOT NULL, `langVariantLastChangedBy` INTEGER NOT NULL, `langVariantLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `PersonAuth` (`personAuthUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `passwordHash` TEXT, `personAuthStatus` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `PersonGroup` (`groupUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `groupMasterCsn` INTEGER NOT NULL, `groupLocalCsn` INTEGER NOT NULL, `groupLastChangedBy` INTEGER NOT NULL, `groupLct` INTEGER NOT NULL, `groupName` TEXT, `groupActive` INTEGER NOT NULL, `personGroupFlag` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `PersonGroupMember` (`groupMemberUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `groupMemberActive` INTEGER NOT NULL, `groupMemberPersonUid` INTEGER NOT NULL, `groupMemberGroupUid` INTEGER NOT NULL, `groupMemberMasterCsn` INTEGER NOT NULL, `groupMemberLocalCsn` INTEGER NOT NULL, `groupMemberLastChangedBy` INTEGER NOT NULL, `groupMemberLct` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_PersonGroupMember_groupMemberPersonUid` ON `PersonGroupMember` (`groupMemberPersonUid`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_PersonGroupMember_groupMemberGroupUid` ON `PersonGroupMember` (`groupMemberGroupUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `PersonPicture` (`personPictureUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `personPictureLct` INTEGER NOT NULL, `personPictureUri` TEXT, `personPictureThumbnailUri` TEXT, `fileSize` INTEGER NOT NULL, `personPictureActive` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `VerbEntity` (`verbUid` INTEGER NOT NULL, `verbUrlId` TEXT, `verbDeleted` INTEGER NOT NULL, `verbLct` INTEGER NOT NULL, PRIMARY KEY(`verbUid`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ActivityEntity` (`actUid` INTEGER NOT NULL, `actIdIri` TEXT, `actType` TEXT, `actMoreInfo` TEXT, `actInteractionType` INTEGER NOT NULL, `actCorrectResponsePatterns` TEXT, `actLct` INTEGER NOT NULL, PRIMARY KEY(`actUid`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `StatementEntity` (`statementIdHi` INTEGER NOT NULL, `statementIdLo` INTEGER NOT NULL, `statementActorPersonUid` INTEGER NOT NULL, `statementVerbUid` INTEGER NOT NULL, `statementObjectType` INTEGER NOT NULL, `statementObjectUid1` INTEGER NOT NULL, `statementObjectUid2` INTEGER NOT NULL, `statementActorUid` INTEGER NOT NULL, `authorityActorUid` INTEGER NOT NULL, `teamUid` INTEGER NOT NULL, `resultCompletion` INTEGER, `resultSuccess` INTEGER, `resultScoreScaled` REAL, `resultScoreRaw` REAL, `resultScoreMin` REAL, `resultScoreMax` REAL, `resultDuration` INTEGER, `resultResponse` TEXT, `timestamp` INTEGER NOT NULL, `stored` INTEGER NOT NULL, `contextRegistrationHi` INTEGER NOT NULL, `contextRegistrationLo` INTEGER NOT NULL, `contextPlatform` TEXT, `contextStatementRefIdHi` INTEGER NOT NULL, `contextStatementRefIdLo` INTEGER NOT NULL, `contextInstructorActorUid` INTEGER NOT NULL, `statementLct` INTEGER NOT NULL, `extensionProgress` INTEGER, `completionOrProgress` INTEGER NOT NULL, `statementContentEntryUid` INTEGER NOT NULL, `statementLearnerGroupUid` INTEGER NOT NULL, `statementClazzUid` INTEGER NOT NULL, `statementCbUid` INTEGER NOT NULL, `statementDoorNode` INTEGER NOT NULL, `isSubStatement` INTEGER NOT NULL, PRIMARY KEY(`statementIdHi`, `statementIdLo`))");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_stmt_actor_person` ON `StatementEntity` (`statementActorPersonUid`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_statement_clazz_person` ON `StatementEntity` (`statementClazzUid`, `statementActorPersonUid`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_statement_cbuid_actor` ON `StatementEntity` (`statementCbUid`, `statementActorUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ActorEntity` (`actorUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `actorPersonUid` INTEGER NOT NULL, `actorName` TEXT, `actorMbox` TEXT, `actorMbox_sha1sum` TEXT, `actorOpenid` TEXT, `actorAccountName` TEXT, `actorAccountHomePage` TEXT, `actorEtag` INTEGER NOT NULL, `actorLct` INTEGER NOT NULL, `actorObjectType` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_actorentity_uid_personuid` ON `ActorEntity` (`actorPersonUid`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_actorentity_actorobjecttype` ON `ActorEntity` (`actorObjectType`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `SyncNode` (`nodeClientId` INTEGER NOT NULL, PRIMARY KEY(`nodeClientId`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `Comments` (`commentsUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `commentsText` TEXT, `commentsEntityUid` INTEGER NOT NULL, `commentsStatus` INTEGER NOT NULL, `commentsFromPersonUid` INTEGER NOT NULL, `commentsForSubmitterUid` INTEGER NOT NULL, `commentsFromSubmitterUid` INTEGER NOT NULL, `commentsFlagged` INTEGER NOT NULL, `commentsDeleted` INTEGER NOT NULL, `commentsDateTimeAdded` INTEGER NOT NULL, `commentsLct` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_comments_entity_submitter` ON `Comments` (`commentsEntityUid`, `commentsForSubmitterUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `Report` (`reportUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `reportOwnerUid` INTEGER NOT NULL, `xAxis` INTEGER NOT NULL, `reportDateRangeSelection` INTEGER NOT NULL, `fromDate` INTEGER NOT NULL, `fromRelTo` INTEGER NOT NULL, `fromRelOffSet` INTEGER NOT NULL, `fromRelUnit` INTEGER NOT NULL, `toDate` INTEGER NOT NULL, `toRelTo` INTEGER NOT NULL, `toRelOffSet` INTEGER NOT NULL, `toRelUnit` INTEGER NOT NULL, `reportTitle` TEXT, `reportDescription` TEXT, `reportSeries` TEXT, `reportInactive` INTEGER NOT NULL, `isTemplate` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `reportTitleId` INTEGER NOT NULL, `reportDescId` INTEGER NOT NULL, `reportMasterChangeSeqNum` INTEGER NOT NULL, `reportLocalChangeSeqNum` INTEGER NOT NULL, `reportLastChangedBy` INTEGER NOT NULL, `reportLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `Site` (`siteUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `sitePcsn` INTEGER NOT NULL, `siteLcsn` INTEGER NOT NULL, `siteLcb` INTEGER NOT NULL, `siteLct` INTEGER NOT NULL, `siteName` TEXT, `guestLogin` INTEGER NOT NULL, `registrationAllowed` INTEGER NOT NULL, `authSalt` TEXT)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `SiteTerms` (`sTermsUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `termsHtml` TEXT, `sTermsLang` TEXT, `sTermsLangUid` INTEGER NOT NULL, `sTermsActive` INTEGER NOT NULL, `sTermsLastChangedBy` INTEGER NOT NULL, `sTermsPrimaryCsn` INTEGER NOT NULL, `sTermsLocalCsn` INTEGER NOT NULL, `sTermsLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `PersonParentJoin` (`ppjUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `ppjPcsn` INTEGER NOT NULL, `ppjLcsn` INTEGER NOT NULL, `ppjLcb` INTEGER NOT NULL, `ppjLct` INTEGER NOT NULL, `ppjParentPersonUid` INTEGER NOT NULL, `ppjMinorPersonUid` INTEGER NOT NULL, `ppjRelationship` INTEGER NOT NULL, `ppjEmail` TEXT, `ppjPhone` TEXT, `ppjInactive` INTEGER NOT NULL, `ppjStatus` INTEGER NOT NULL, `ppjApprovalTiemstamp` INTEGER NOT NULL, `ppjApprovalIpAddr` TEXT)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ScopedGrant` (`sgUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `sgPcsn` INTEGER NOT NULL, `sgLcsn` INTEGER NOT NULL, `sgLcb` INTEGER NOT NULL, `sgLct` INTEGER NOT NULL, `sgTableId` INTEGER NOT NULL, `sgEntityUid` INTEGER NOT NULL, `sgPermissions` INTEGER NOT NULL, `sgGroupUid` INTEGER NOT NULL, `sgIndex` INTEGER NOT NULL, `sgFlags` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_group_to_entity` ON `ScopedGrant` (`sgGroupUid`, `sgPermissions`, `sgTableId`, `sgEntityUid`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_entity_to_group` ON `ScopedGrant` (`sgTableId`, `sgEntityUid`, `sgPermissions`, `sgGroupUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ErrorReport` (`errUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `errPcsn` INTEGER NOT NULL, `errLcsn` INTEGER NOT NULL, `errLcb` INTEGER NOT NULL, `errLct` INTEGER NOT NULL, `severity` INTEGER NOT NULL, `timestamp` INTEGER NOT NULL, `presenterUri` TEXT, `appVersion` TEXT, `versionCode` INTEGER NOT NULL, `errorCode` INTEGER NOT NULL, `operatingSys` TEXT, `osVersion` TEXT, `stackTrace` TEXT, `message` TEXT)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ClazzAssignment` (`caUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `caTitle` TEXT, `caDescription` TEXT, `caGroupUid` INTEGER NOT NULL DEFAULT 0, `caActive` INTEGER NOT NULL, `caClassCommentEnabled` INTEGER NOT NULL, `caPrivateCommentsEnabled` INTEGER NOT NULL DEFAULT 1, `caCompletionCriteria` INTEGER NOT NULL DEFAULT 100, `caRequireFileSubmission` INTEGER NOT NULL DEFAULT 1, `caFileType` INTEGER NOT NULL DEFAULT 0, `caSizeLimit` INTEGER NOT NULL DEFAULT 50, `caNumberOfFiles` INTEGER NOT NULL DEFAULT 1, `caSubmissionPolicy` INTEGER NOT NULL DEFAULT 1, `caMarkingType` INTEGER NOT NULL DEFAULT 1, `caRequireTextSubmission` INTEGER NOT NULL DEFAULT 1, `caTextLimitType` INTEGER NOT NULL DEFAULT 1, `caTextLimit` INTEGER NOT NULL DEFAULT 500, `caXObjectUid` INTEGER NOT NULL DEFAULT 0, `caClazzUid` INTEGER NOT NULL, `caPeerReviewerCount` INTEGER NOT NULL DEFAULT 0, `caLocalChangeSeqNum` INTEGER NOT NULL, `caMasterChangeSeqNum` INTEGER NOT NULL, `caLastChangedBy` INTEGER NOT NULL, `caLct` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_ClazzAssignment_caClazzUid` ON `ClazzAssignment` (`caClazzUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `CourseAssignmentSubmission` (`casUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `casAssignmentUid` INTEGER NOT NULL, `casSubmitterUid` INTEGER NOT NULL, `casSubmitterPersonUid` INTEGER NOT NULL, `casText` TEXT, `casType` INTEGER NOT NULL, `casTimestamp` INTEGER NOT NULL, `casClazzUid` INTEGER NOT NULL DEFAULT 0)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `CourseAssignmentSubmissionFile` (`casaUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `casaSubmissionUid` INTEGER NOT NULL, `casaSubmitterUid` INTEGER NOT NULL DEFAULT 0, `casaCaUid` INTEGER NOT NULL, `casaClazzUid` INTEGER NOT NULL, `casaMimeType` TEXT, `casaFileName` TEXT, `casaUri` TEXT, `casaSize` INTEGER NOT NULL, `casaTimestamp` INTEGER NOT NULL, `casaDeleted` INTEGER NOT NULL DEFAULT 0)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `CourseAssignmentMark` (`camUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `camAssignmentUid` INTEGER NOT NULL, `camSubmitterUid` INTEGER NOT NULL, `camMarkerSubmitterUid` INTEGER NOT NULL DEFAULT 0, `camMarkerPersonUid` INTEGER NOT NULL DEFAULT 0, `camMarkerComment` TEXT, `camMark` REAL NOT NULL, `camMaxMark` REAL NOT NULL DEFAULT 1, `camPenalty` REAL NOT NULL, `camLct` INTEGER NOT NULL, `camClazzUid` INTEGER NOT NULL DEFAULT 0)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `PeerReviewerAllocation` (`praUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `praMarkerSubmitterUid` INTEGER NOT NULL, `praToMarkerSubmitterUid` INTEGER NOT NULL, `praAssignmentUid` INTEGER NOT NULL, `praActive` INTEGER NOT NULL, `praLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `PersonAuth2` (`pauthUid` INTEGER NOT NULL, `pauthMechanism` TEXT, `pauthAuth` TEXT, `pauthLcsn` INTEGER NOT NULL, `pauthPcsn` INTEGER NOT NULL, `pauthLcb` INTEGER NOT NULL, `pauthLct` INTEGER NOT NULL, PRIMARY KEY(`pauthUid`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `UserSession` (`usUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `usPcsn` INTEGER NOT NULL, `usLcsn` INTEGER NOT NULL, `usLcb` INTEGER NOT NULL, `usLct` INTEGER NOT NULL, `usPersonUid` INTEGER NOT NULL, `usClientNodeId` INTEGER NOT NULL, `usStartTime` INTEGER NOT NULL, `usEndTime` INTEGER NOT NULL, `usStatus` INTEGER NOT NULL, `usReason` INTEGER NOT NULL, `usAuth` TEXT, `usSessionType` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `person_status_node_idx` ON `UserSession` (`usPersonUid`, `usStatus`, `usClientNodeId`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `node_status_person_idx` ON `UserSession` (`usClientNodeId`, `usStatus`, `usPersonUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ContentJob` (`cjUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `toUri` TEXT, `cjProgress` INTEGER NOT NULL, `cjTotal` INTEGER NOT NULL, `cjNotificationTitle` TEXT, `cjIsMeteredAllowed` INTEGER NOT NULL, `params` TEXT, `cjLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ContentEntryImportJob` (`cjiUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `sourceUri` TEXT, `cjiOriginalFilename` TEXT, `cjiContentEntryUid` INTEGER NOT NULL, `cjiParentContentEntryUid` INTEGER NOT NULL, `cjiContentEntryVersion` INTEGER NOT NULL, `cjiItemProgress` INTEGER NOT NULL, `cjiItemTotal` INTEGER NOT NULL, `cjiStatus` INTEGER NOT NULL, `cjiRecursiveStatus` INTEGER NOT NULL, `cjiPluginId` INTEGER NOT NULL, `cjiParentCjiUid` INTEGER NOT NULL, `cjiStartTime` INTEGER NOT NULL, `cjiFinishTime` INTEGER NOT NULL, `cjiContentDeletedOnCancellation` INTEGER NOT NULL, `cjiCompressionLevel` INTEGER NOT NULL DEFAULT 3, `cjiError` TEXT, `cjiErrorDismissed` INTEGER NOT NULL, `cjiOwnerPersonUid` INTEGER NOT NULL, `cjiParams` TEXT)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_ContentEntryImportJob_cjiContentEntryUid_cjiFinishTime` ON `ContentEntryImportJob` (`cjiContentEntryUid`, `cjiFinishTime`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `CourseBlock` (`cbUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `cbType` INTEGER NOT NULL, `cbIndentLevel` INTEGER NOT NULL, `cbModuleParentBlockUid` INTEGER NOT NULL, `cbTitle` TEXT, `cbDescription` TEXT, `cbCompletionCriteria` INTEGER NOT NULL, `cbHideUntilDate` INTEGER NOT NULL, `cbDeadlineDate` INTEGER NOT NULL, `cbLateSubmissionPenalty` INTEGER NOT NULL, `cbGracePeriodDate` INTEGER NOT NULL, `cbMaxPoints` REAL, `cbMinPoints` REAL, `cbIndex` INTEGER NOT NULL, `cbClazzUid` INTEGER NOT NULL, `cbClazzSourcedId` TEXT, `cbActive` INTEGER NOT NULL, `cbHidden` INTEGER NOT NULL, `cbEntityUid` INTEGER NOT NULL, `cbLct` INTEGER NOT NULL, `cbSourcedId` TEXT, `cbMetadata` TEXT, `cbCreatedByAppId` TEXT)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_courseblock_cbclazzuid` ON `CourseBlock` (`cbClazzUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `CourseTerminology` (`ctUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `ctTitle` TEXT, `ctTerminology` TEXT, `ctLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `CourseGroupSet` (`cgsUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `cgsName` TEXT, `cgsTotalGroups` INTEGER NOT NULL, `cgsActive` INTEGER NOT NULL, `cgsClazzUid` INTEGER NOT NULL, `cgsLct` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `index_CourseGroupSet_cgsClazzUid` ON `CourseGroupSet` (`cgsClazzUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `CourseGroupMember` (`cgmUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `cgmSetUid` INTEGER NOT NULL, `cgmGroupNumber` INTEGER NOT NULL, `cgmPersonUid` INTEGER NOT NULL, `cgmLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ContentEntryPicture` (`cepUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `cepContentEntryUid` INTEGER NOT NULL, `cepUri` TEXT, `cepMd5` TEXT, `cepFileSize` INTEGER NOT NULL, `cepTimestamp` INTEGER NOT NULL, `cepMimeType` TEXT, `cepActive` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ActivityInteractionEntity` (`aieActivityUid` INTEGER NOT NULL, `aieHash` INTEGER NOT NULL, `aieProp` INTEGER NOT NULL, `aieId` TEXT, `aieLastMod` INTEGER NOT NULL, `aieIsDeleted` INTEGER NOT NULL, PRIMARY KEY(`aieActivityUid`, `aieHash`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `CoursePicture` (`coursePictureUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `coursePictureLct` INTEGER NOT NULL, `coursePictureUri` TEXT, `coursePictureThumbnailUri` TEXT, `coursePictureActive` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `DiscussionPost` (`discussionPostUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `discussionPostReplyToPostUid` INTEGER NOT NULL, `discussionPostTitle` TEXT, `discussionPostMessage` TEXT, `discussionPostStartDate` INTEGER NOT NULL, `discussionPostCourseBlockUid` INTEGER NOT NULL, `dpDeleted` INTEGER NOT NULL, `discussionPostStartedPersonUid` INTEGER NOT NULL, `discussionPostClazzUid` INTEGER NOT NULL, `discussionPostLct` INTEGER NOT NULL, `discussionPostVisible` INTEGER NOT NULL, `discussionPostArchive` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ExternalAppPermission` (`eapUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `eapPersonUid` INTEGER NOT NULL, `eapPackageId` TEXT, `eapStartTime` INTEGER NOT NULL, `eapExpireTime` INTEGER NOT NULL, `eapAuthToken` TEXT, `eapAndroidAccountName` TEXT)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `Message` (`messageUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `messageSenderPersonUid` INTEGER NOT NULL, `messageToPersonUid` INTEGER NOT NULL, `messageText` TEXT, `messageTimestamp` INTEGER NOT NULL, `messageLct` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `message_idx_send_to_time` ON `Message` (`messageSenderPersonUid`, `messageToPersonUid`, `messageTimestamp`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `StudentResult` (`srUid` INTEGER NOT NULL, `srSourcedId` TEXT, `srCourseBlockUid` INTEGER NOT NULL, `srLineItemSourcedId` TEXT, `srLineItemHref` TEXT, `srClazzUid` INTEGER NOT NULL, `srAssignmentUid` INTEGER NOT NULL, `srStatus` INTEGER NOT NULL, `srMetaData` TEXT, `srStudentPersonUid` INTEGER NOT NULL, `srStudentPersonSourcedId` TEXT, `srStudentGroupId` INTEGER NOT NULL, `srMarkerPersonUid` INTEGER NOT NULL, `srMarkerGroupId` INTEGER NOT NULL, `srScoreStatus` INTEGER NOT NULL, `srScore` REAL NOT NULL, `srScoreDate` INTEGER NOT NULL, `srLastModified` INTEGER NOT NULL, `srComment` TEXT, `srAppId` TEXT, `srDeleted` INTEGER NOT NULL, PRIMARY KEY(`srUid`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ContentEntryVersion` (`cevUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `cevContentEntryUid` INTEGER NOT NULL, `cevOpenUri` TEXT, `cevContentType` TEXT, `cevManifestUrl` TEXT, `cevSize` INTEGER NOT NULL, `cevInActive` INTEGER NOT NULL, `cevLastModified` INTEGER NOT NULL, `cevLct` INTEGER NOT NULL, `cevStorageSize` INTEGER NOT NULL DEFAULT 0, `cevOriginalSize` INTEGER NOT NULL DEFAULT 0)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `TransferJob` (`tjUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `tjType` INTEGER NOT NULL, `tjStatus` INTEGER NOT NULL, `tjName` TEXT, `tjUuid` TEXT, `tjTableId` INTEGER NOT NULL DEFAULT 0, `tjEntityUid` INTEGER NOT NULL DEFAULT 0, `tjTimeCreated` INTEGER NOT NULL DEFAULT 0, `tjCreationType` INTEGER NOT NULL DEFAULT 0, `tjOiUid` INTEGER NOT NULL DEFAULT 0)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `TransferJob_idx_tjTableId_EntityUid` ON `TransferJob` (`tjTableId`, `tjEntityUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `TransferJobItem` (`tjiUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `tjiTjUid` INTEGER NOT NULL, `tjTotalSize` INTEGER NOT NULL, `tjTransferred` INTEGER NOT NULL, `tjAttemptCount` INTEGER NOT NULL, `tjiSrc` TEXT, `tjiDest` TEXT, `tjiType` INTEGER NOT NULL, `tjiStatus` INTEGER NOT NULL, `tjiTableId` INTEGER NOT NULL, `tjiEntityUid` INTEGER NOT NULL, `tjiEntityEtag` INTEGER NOT NULL DEFAULT 0, `tjiLockIdToRelease` INTEGER NOT NULL DEFAULT 0, `tjiPartialTmpFile` TEXT)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `tji_table_entity_etag` ON `TransferJobItem` (`tjiTableId`, `tjiEntityUid`, `tjiEntityEtag`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `transferjob_tjuid` ON `TransferJobItem` (`tjiTjUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `CacheLockJoin` (`cljId` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `cljTableId` INTEGER NOT NULL, `cljEntityUid` INTEGER NOT NULL, `cljUrl` TEXT, `cljLockId` INTEGER NOT NULL, `cljStatus` INTEGER NOT NULL, `cljType` INTEGER NOT NULL, `cljOiUid` INTEGER NOT NULL DEFAULT 0)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_clj_table_entity_url` ON `CacheLockJoin` (`cljTableId`, `cljEntityUid`, `cljUrl`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_clj_offline_item_uid` ON `CacheLockJoin` (`cljOiUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `OfflineItem` (`oiUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `oiNodeId` INTEGER NOT NULL, `oiClazzUid` INTEGER NOT NULL, `oiCourseBlockUid` INTEGER NOT NULL, `oiContentEntryUid` INTEGER NOT NULL, `oiActive` INTEGER NOT NULL, `oiLct` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `offline_item_node_content_entry` ON `OfflineItem` (`oiNodeId`, `oiContentEntryUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `OfflineItemPendingTransferJob` (`oiptjId` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `oiptjOiUid` INTEGER NOT NULL, `oiptjTableId` INTEGER NOT NULL, `oiptjEntityUid` INTEGER NOT NULL, `oiptjUrl` TEXT, `oiptjType` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `DeletedItem` (`delItemUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `delItemName` TEXT, `delItemIconUri` TEXT, `delItemLastModTime` INTEGER NOT NULL, `delItemTimeDeleted` INTEGER NOT NULL, `delItemEntityTable` INTEGER NOT NULL, `delItemEntityUid` INTEGER NOT NULL, `delItemDeletedByPersonUid` INTEGER NOT NULL, `delItemStatus` INTEGER NOT NULL, `delItemIsFolder` INTEGER NOT NULL DEFAULT 0)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `delitem_idx_status_time` ON `DeletedItem` (`delItemStatus`, `delItemTimeDeleted`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `EnrolmentRequest` (`erUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `erClazzUid` INTEGER NOT NULL, `erClazzName` TEXT, `erPersonUid` INTEGER NOT NULL, `erPersonFullname` TEXT, `erPersonPictureUri` TEXT, `erPersonUsername` TEXT, `erRole` INTEGER NOT NULL, `erRequestTime` INTEGER NOT NULL, `erStatus` INTEGER NOT NULL, `erStatusSetByPersonUid` INTEGER NOT NULL, `erDeleted` INTEGER NOT NULL, `erStatusSetAuth` TEXT, `erLastModified` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_enrolmentrequest_by_clazz` ON `EnrolmentRequest` (`erClazzUid`, `erStatus`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_enrolmentrequest_by_person` ON `EnrolmentRequest` (`erPersonUid`, `erStatus`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `CoursePermission` (`cpUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `cpLastModified` INTEGER NOT NULL, `cpClazzUid` INTEGER NOT NULL, `cpToEnrolmentRole` INTEGER NOT NULL, `cpToPersonUid` INTEGER NOT NULL, `cpToGroupUid` INTEGER NOT NULL, `cpPermissionsFlag` INTEGER NOT NULL, `cpIsDeleted` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_coursepermission_clazzuid` ON `CoursePermission` (`cpClazzUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `SystemPermission` (`spUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `spToPersonUid` INTEGER NOT NULL, `spToGroupUid` INTEGER NOT NULL, `spPermissionsFlag` INTEGER NOT NULL, `spLastModified` INTEGER NOT NULL, `spIsDeleted` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_systempermission_personuid` ON `SystemPermission` (`spToPersonUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `CourseBlockPicture` (`cbpUid` INTEGER NOT NULL, `cbpLct` INTEGER NOT NULL, `cbpPictureUri` TEXT, `cbpThumbnailUri` TEXT, PRIMARY KEY(`cbpUid`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ContentEntryPicture2` (`cepUid` INTEGER NOT NULL, `cepLct` INTEGER NOT NULL, `cepPictureUri` TEXT, `cepThumbnailUri` TEXT, PRIMARY KEY(`cepUid`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `TransferJobError` (`tjeId` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `tjeTjUid` INTEGER NOT NULL, `tjeTime` INTEGER NOT NULL, `tjeErrorStr` TEXT, `tjeDismissed` INTEGER NOT NULL)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_transferjoberror_tjetjuid` ON `TransferJobError` (`tjeTjUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `VerbLangMapEntry` (`vlmeVerbUid` INTEGER NOT NULL, `vlmeLangHash` INTEGER NOT NULL, `vlmeLangCode` TEXT, `vlmeEntryString` TEXT, `vlmeLastModified` INTEGER NOT NULL, PRIMARY KEY(`vlmeVerbUid`, `vlmeLangHash`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `GroupMemberActorJoin` (`gmajGroupActorUid` INTEGER NOT NULL, `gmajMemberActorUid` INTEGER NOT NULL, `gmajLastMod` INTEGER NOT NULL, PRIMARY KEY(`gmajGroupActorUid`, `gmajMemberActorUid`))");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_groupmemberactorjoin_gmajgroupactoruid` ON `GroupMemberActorJoin` (`gmajGroupActorUid`)");
        db.execSQL("CREATE INDEX IF NOT EXISTS `idx_groupmemberactorjoin_gmajmemberactoruid` ON `GroupMemberActorJoin` (`gmajMemberActorUid`)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ActivityLangMapEntry` (`almeActivityUid` INTEGER NOT NULL, `almeHash` INTEGER NOT NULL, `almeLangCode` TEXT, `almePropName` TEXT, `almeValue` TEXT, `almeAieHash` INTEGER NOT NULL, `almeLastMod` INTEGER NOT NULL, PRIMARY KEY(`almeActivityUid`, `almeHash`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ActivityExtensionEntity` (`aeeActivityUid` INTEGER NOT NULL, `aeeKeyHash` INTEGER NOT NULL, `aeeKey` TEXT, `aeeJson` TEXT, `aeeLastMod` INTEGER NOT NULL, `aeeIsDeleted` INTEGER NOT NULL, PRIMARY KEY(`aeeActivityUid`, `aeeKeyHash`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `StatementContextActivityJoin` (`scajFromStatementIdHi` INTEGER NOT NULL, `scajFromStatementIdLo` INTEGER NOT NULL, `scajToHash` INTEGER NOT NULL, `scajContextType` INTEGER NOT NULL, `scajToActivityUid` INTEGER NOT NULL, `scajToActivityId` TEXT, `scajEtag` INTEGER NOT NULL, PRIMARY KEY(`scajFromStatementIdHi`, `scajFromStatementIdLo`, `scajToHash`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `XapiSessionEntity` (`xseUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `xseLastMod` INTEGER NOT NULL, `xseRegistrationHi` INTEGER NOT NULL, `xseRegistrationLo` INTEGER NOT NULL, `xseUsUid` INTEGER NOT NULL, `xseAccountPersonUid` INTEGER NOT NULL, `xseActorUid` INTEGER NOT NULL, `xseAccountUsername` TEXT NOT NULL, `xseClazzUid` INTEGER NOT NULL, `xseCbUid` INTEGER NOT NULL, `xseContentEntryUid` INTEGER NOT NULL, `xseContentEntryVersionUid` INTEGER NOT NULL DEFAULT 0, `xseRootActivityId` TEXT NOT NULL, `xseRootActivityUid` INTEGER NOT NULL, `xseStartTime` INTEGER NOT NULL, `xseExpireTime` INTEGER NOT NULL, `xseAuth` TEXT, `xseCompleted` INTEGER NOT NULL DEFAULT 0, `knownActorUidToPersonUids` TEXT NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `StatementEntityJson` (`stmtJsonIdHi` INTEGER NOT NULL, `stmtJsonIdLo` INTEGER NOT NULL, `stmtEtag` INTEGER NOT NULL, `fullStatement` TEXT, PRIMARY KEY(`stmtJsonIdHi`, `stmtJsonIdLo`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `PersonPasskey` (`personPasskeyUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `ppPersonUid` INTEGER NOT NULL, `ppAttestationObj` TEXT, `ppClientDataJson` TEXT, `ppOriginString` TEXT, `ppId` TEXT, `ppChallengeString` TEXT, `ppPublicKey` TEXT, `isRevoked` INTEGER NOT NULL, `ppPasskeyLct` INTEGER NOT NULL)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `StateEntity` (`seActorUid` INTEGER NOT NULL, `seHash` INTEGER NOT NULL, `seActivityUid` INTEGER NOT NULL, `seStateId` TEXT NOT NULL, `seLastMod` INTEGER NOT NULL, `seTimeStored` INTEGER NOT NULL, `seContentType` TEXT NOT NULL, `seCompressed` INTEGER NOT NULL, `seContent` TEXT NOT NULL, `seDeleted` INTEGER NOT NULL, `seRegistrationHi` INTEGER, `seRegistrationLo` INTEGER, `seH5PPreloaded` INTEGER NOT NULL, `seH5PSubContentId` TEXT, PRIMARY KEY(`seActorUid`, `seHash`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `StateDeleteCommand` (`sdcActorUid` INTEGER NOT NULL, `sdcHash` INTEGER NOT NULL, `sdcActivityUid` INTEGER NOT NULL, `sdcStateId` TEXT, `sdcLastMod` INTEGER NOT NULL, `sdcRegistrationHi` INTEGER, `sdcRegistrationLo` INTEGER, PRIMARY KEY(`sdcActorUid`, `sdcHash`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `OutgoingReplication` (`orUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `destNodeId` INTEGER NOT NULL, `orTableId` INTEGER NOT NULL, `orPk1` INTEGER NOT NULL, `orPk2` INTEGER NOT NULL DEFAULT 0, `orPk3` INTEGER NOT NULL DEFAULT 0, `orPk4` INTEGER NOT NULL DEFAULT 0)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `ReplicationOperation` (`repOpRemoteNodeId` INTEGER NOT NULL, `repOpTableId` INTEGER NOT NULL, `repOpStatus` INTEGER NOT NULL, PRIMARY KEY(`repOpRemoteNodeId`, `repOpTableId`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS `PendingRepositorySession` (`rsUid` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `remoteNodeId` INTEGER NOT NULL, `endpointUrl` TEXT)");
        db.execSQL("CREATE TABLE IF NOT EXISTS `DoorNode` (`nodeId` INTEGER NOT NULL, `auth` TEXT, `rel` INTEGER NOT NULL DEFAULT 2, PRIMARY KEY(`nodeId`))");
        db.execSQL("CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)");
        db.execSQL("INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '9bec28e0e31ae15d6a349b56de026a6f')");
      }

      @Override
      public void dropAllTables(@NonNull final SupportSQLiteDatabase db) {
        db.execSQL("DROP TABLE IF EXISTS `ClazzLog`");
        db.execSQL("DROP TABLE IF EXISTS `ClazzLogAttendanceRecord`");
        db.execSQL("DROP TABLE IF EXISTS `Schedule`");
        db.execSQL("DROP TABLE IF EXISTS `HolidayCalendar`");
        db.execSQL("DROP TABLE IF EXISTS `Holiday`");
        db.execSQL("DROP TABLE IF EXISTS `Person`");
        db.execSQL("DROP TABLE IF EXISTS `Clazz`");
        db.execSQL("DROP TABLE IF EXISTS `ClazzEnrolment`");
        db.execSQL("DROP TABLE IF EXISTS `LeavingReason`");
        db.execSQL("DROP TABLE IF EXISTS `ClazzInvite`");
        db.execSQL("DROP TABLE IF EXISTS `ContentEntry`");
        db.execSQL("DROP TABLE IF EXISTS `ContentEntryContentCategoryJoin`");
        db.execSQL("DROP TABLE IF EXISTS `ContentEntryParentChildJoin`");
        db.execSQL("DROP TABLE IF EXISTS `ContentEntryRelatedEntryJoin`");
        db.execSQL("DROP TABLE IF EXISTS `ContentCategorySchema`");
        db.execSQL("DROP TABLE IF EXISTS `ContentCategory`");
        db.execSQL("DROP TABLE IF EXISTS `Language`");
        db.execSQL("DROP TABLE IF EXISTS `LanguageVariant`");
        db.execSQL("DROP TABLE IF EXISTS `PersonAuth`");
        db.execSQL("DROP TABLE IF EXISTS `PersonGroup`");
        db.execSQL("DROP TABLE IF EXISTS `PersonGroupMember`");
        db.execSQL("DROP TABLE IF EXISTS `PersonPicture`");
        db.execSQL("DROP TABLE IF EXISTS `VerbEntity`");
        db.execSQL("DROP TABLE IF EXISTS `ActivityEntity`");
        db.execSQL("DROP TABLE IF EXISTS `StatementEntity`");
        db.execSQL("DROP TABLE IF EXISTS `ActorEntity`");
        db.execSQL("DROP TABLE IF EXISTS `SyncNode`");
        db.execSQL("DROP TABLE IF EXISTS `Comments`");
        db.execSQL("DROP TABLE IF EXISTS `Report`");
        db.execSQL("DROP TABLE IF EXISTS `Site`");
        db.execSQL("DROP TABLE IF EXISTS `SiteTerms`");
        db.execSQL("DROP TABLE IF EXISTS `PersonParentJoin`");
        db.execSQL("DROP TABLE IF EXISTS `ScopedGrant`");
        db.execSQL("DROP TABLE IF EXISTS `ErrorReport`");
        db.execSQL("DROP TABLE IF EXISTS `ClazzAssignment`");
        db.execSQL("DROP TABLE IF EXISTS `CourseAssignmentSubmission`");
        db.execSQL("DROP TABLE IF EXISTS `CourseAssignmentSubmissionFile`");
        db.execSQL("DROP TABLE IF EXISTS `CourseAssignmentMark`");
        db.execSQL("DROP TABLE IF EXISTS `PeerReviewerAllocation`");
        db.execSQL("DROP TABLE IF EXISTS `PersonAuth2`");
        db.execSQL("DROP TABLE IF EXISTS `UserSession`");
        db.execSQL("DROP TABLE IF EXISTS `ContentJob`");
        db.execSQL("DROP TABLE IF EXISTS `ContentEntryImportJob`");
        db.execSQL("DROP TABLE IF EXISTS `CourseBlock`");
        db.execSQL("DROP TABLE IF EXISTS `CourseTerminology`");
        db.execSQL("DROP TABLE IF EXISTS `CourseGroupSet`");
        db.execSQL("DROP TABLE IF EXISTS `CourseGroupMember`");
        db.execSQL("DROP TABLE IF EXISTS `ContentEntryPicture`");
        db.execSQL("DROP TABLE IF EXISTS `ActivityInteractionEntity`");
        db.execSQL("DROP TABLE IF EXISTS `CoursePicture`");
        db.execSQL("DROP TABLE IF EXISTS `DiscussionPost`");
        db.execSQL("DROP TABLE IF EXISTS `ExternalAppPermission`");
        db.execSQL("DROP TABLE IF EXISTS `Message`");
        db.execSQL("DROP TABLE IF EXISTS `StudentResult`");
        db.execSQL("DROP TABLE IF EXISTS `ContentEntryVersion`");
        db.execSQL("DROP TABLE IF EXISTS `TransferJob`");
        db.execSQL("DROP TABLE IF EXISTS `TransferJobItem`");
        db.execSQL("DROP TABLE IF EXISTS `CacheLockJoin`");
        db.execSQL("DROP TABLE IF EXISTS `OfflineItem`");
        db.execSQL("DROP TABLE IF EXISTS `OfflineItemPendingTransferJob`");
        db.execSQL("DROP TABLE IF EXISTS `DeletedItem`");
        db.execSQL("DROP TABLE IF EXISTS `EnrolmentRequest`");
        db.execSQL("DROP TABLE IF EXISTS `CoursePermission`");
        db.execSQL("DROP TABLE IF EXISTS `SystemPermission`");
        db.execSQL("DROP TABLE IF EXISTS `CourseBlockPicture`");
        db.execSQL("DROP TABLE IF EXISTS `ContentEntryPicture2`");
        db.execSQL("DROP TABLE IF EXISTS `TransferJobError`");
        db.execSQL("DROP TABLE IF EXISTS `VerbLangMapEntry`");
        db.execSQL("DROP TABLE IF EXISTS `GroupMemberActorJoin`");
        db.execSQL("DROP TABLE IF EXISTS `ActivityLangMapEntry`");
        db.execSQL("DROP TABLE IF EXISTS `ActivityExtensionEntity`");
        db.execSQL("DROP TABLE IF EXISTS `StatementContextActivityJoin`");
        db.execSQL("DROP TABLE IF EXISTS `XapiSessionEntity`");
        db.execSQL("DROP TABLE IF EXISTS `StatementEntityJson`");
        db.execSQL("DROP TABLE IF EXISTS `PersonPasskey`");
        db.execSQL("DROP TABLE IF EXISTS `StateEntity`");
        db.execSQL("DROP TABLE IF EXISTS `StateDeleteCommand`");
        db.execSQL("DROP TABLE IF EXISTS `OutgoingReplication`");
        db.execSQL("DROP TABLE IF EXISTS `ReplicationOperation`");
        db.execSQL("DROP TABLE IF EXISTS `PendingRepositorySession`");
        db.execSQL("DROP TABLE IF EXISTS `DoorNode`");
        final List<? extends RoomDatabase.Callback> _callbacks = mCallbacks;
        if (_callbacks != null) {
          for (RoomDatabase.Callback _callback : _callbacks) {
            _callback.onDestructiveMigration(db);
          }
        }
      }

      @Override
      public void onCreate(@NonNull final SupportSQLiteDatabase db) {
        final List<? extends RoomDatabase.Callback> _callbacks = mCallbacks;
        if (_callbacks != null) {
          for (RoomDatabase.Callback _callback : _callbacks) {
            _callback.onCreate(db);
          }
        }
      }

      @Override
      public void onOpen(@NonNull final SupportSQLiteDatabase db) {
        mDatabase = db;
        internalInitInvalidationTracker(db);
        final List<? extends RoomDatabase.Callback> _callbacks = mCallbacks;
        if (_callbacks != null) {
          for (RoomDatabase.Callback _callback : _callbacks) {
            _callback.onOpen(db);
          }
        }
      }

      @Override
      public void onPreMigrate(@NonNull final SupportSQLiteDatabase db) {
        DBUtil.dropFtsSyncTriggers(db);
      }

      @Override
      public void onPostMigrate(@NonNull final SupportSQLiteDatabase db) {
      }

      @Override
      @NonNull
      public RoomOpenHelper.ValidationResult onValidateSchema(
          @NonNull final SupportSQLiteDatabase db) {
        final HashMap<String, TableInfo.Column> _columnsClazzLog = new HashMap<String, TableInfo.Column>(16);
        _columnsClazzLog.put("clazzLogUid", new TableInfo.Column("clazzLogUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("clazzLogClazzUid", new TableInfo.Column("clazzLogClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("logDate", new TableInfo.Column("logDate", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("timeRecorded", new TableInfo.Column("timeRecorded", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("clazzLogDone", new TableInfo.Column("clazzLogDone", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("cancellationNote", new TableInfo.Column("cancellationNote", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("clazzLogCancelled", new TableInfo.Column("clazzLogCancelled", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("clazzLogNumPresent", new TableInfo.Column("clazzLogNumPresent", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("clazzLogNumAbsent", new TableInfo.Column("clazzLogNumAbsent", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("clazzLogNumPartial", new TableInfo.Column("clazzLogNumPartial", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("clazzLogScheduleUid", new TableInfo.Column("clazzLogScheduleUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("clazzLogStatusFlag", new TableInfo.Column("clazzLogStatusFlag", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("clazzLogMSQN", new TableInfo.Column("clazzLogMSQN", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("clazzLogLCSN", new TableInfo.Column("clazzLogLCSN", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("clazzLogLCB", new TableInfo.Column("clazzLogLCB", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLog.put("clazzLogLastChangedTime", new TableInfo.Column("clazzLogLastChangedTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysClazzLog = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesClazzLog = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoClazzLog = new TableInfo("ClazzLog", _columnsClazzLog, _foreignKeysClazzLog, _indicesClazzLog);
        final TableInfo _existingClazzLog = TableInfo.read(db, "ClazzLog");
        if (!_infoClazzLog.equals(_existingClazzLog)) {
          return new RoomOpenHelper.ValidationResult(false, "ClazzLog(com.ustadmobile.lib.db.entities.ClazzLog).\n"
                  + " Expected:\n" + _infoClazzLog + "\n"
                  + " Found:\n" + _existingClazzLog);
        }
        final HashMap<String, TableInfo.Column> _columnsClazzLogAttendanceRecord = new HashMap<String, TableInfo.Column>(8);
        _columnsClazzLogAttendanceRecord.put("clazzLogAttendanceRecordUid", new TableInfo.Column("clazzLogAttendanceRecordUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLogAttendanceRecord.put("clazzLogAttendanceRecordClazzLogUid", new TableInfo.Column("clazzLogAttendanceRecordClazzLogUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLogAttendanceRecord.put("clazzLogAttendanceRecordPersonUid", new TableInfo.Column("clazzLogAttendanceRecordPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLogAttendanceRecord.put("attendanceStatus", new TableInfo.Column("attendanceStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLogAttendanceRecord.put("clazzLogAttendanceRecordMasterChangeSeqNum", new TableInfo.Column("clazzLogAttendanceRecordMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLogAttendanceRecord.put("clazzLogAttendanceRecordLocalChangeSeqNum", new TableInfo.Column("clazzLogAttendanceRecordLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLogAttendanceRecord.put("clazzLogAttendanceRecordLastChangedBy", new TableInfo.Column("clazzLogAttendanceRecordLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzLogAttendanceRecord.put("clazzLogAttendanceRecordLastChangedTime", new TableInfo.Column("clazzLogAttendanceRecordLastChangedTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysClazzLogAttendanceRecord = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesClazzLogAttendanceRecord = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoClazzLogAttendanceRecord = new TableInfo("ClazzLogAttendanceRecord", _columnsClazzLogAttendanceRecord, _foreignKeysClazzLogAttendanceRecord, _indicesClazzLogAttendanceRecord);
        final TableInfo _existingClazzLogAttendanceRecord = TableInfo.read(db, "ClazzLogAttendanceRecord");
        if (!_infoClazzLogAttendanceRecord.equals(_existingClazzLogAttendanceRecord)) {
          return new RoomOpenHelper.ValidationResult(false, "ClazzLogAttendanceRecord(com.ustadmobile.lib.db.entities.ClazzLogAttendanceRecord).\n"
                  + " Expected:\n" + _infoClazzLogAttendanceRecord + "\n"
                  + " Found:\n" + _existingClazzLogAttendanceRecord);
        }
        final HashMap<String, TableInfo.Column> _columnsSchedule = new HashMap<String, TableInfo.Column>(13);
        _columnsSchedule.put("scheduleUid", new TableInfo.Column("scheduleUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSchedule.put("sceduleStartTime", new TableInfo.Column("sceduleStartTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSchedule.put("scheduleEndTime", new TableInfo.Column("scheduleEndTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSchedule.put("scheduleDay", new TableInfo.Column("scheduleDay", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSchedule.put("scheduleMonth", new TableInfo.Column("scheduleMonth", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSchedule.put("scheduleFrequency", new TableInfo.Column("scheduleFrequency", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSchedule.put("umCalendarUid", new TableInfo.Column("umCalendarUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSchedule.put("scheduleClazzUid", new TableInfo.Column("scheduleClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSchedule.put("scheduleMasterChangeSeqNum", new TableInfo.Column("scheduleMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSchedule.put("scheduleLocalChangeSeqNum", new TableInfo.Column("scheduleLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSchedule.put("scheduleLastChangedBy", new TableInfo.Column("scheduleLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSchedule.put("scheduleLastChangedTime", new TableInfo.Column("scheduleLastChangedTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSchedule.put("scheduleActive", new TableInfo.Column("scheduleActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysSchedule = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesSchedule = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoSchedule = new TableInfo("Schedule", _columnsSchedule, _foreignKeysSchedule, _indicesSchedule);
        final TableInfo _existingSchedule = TableInfo.read(db, "Schedule");
        if (!_infoSchedule.equals(_existingSchedule)) {
          return new RoomOpenHelper.ValidationResult(false, "Schedule(com.ustadmobile.lib.db.entities.Schedule).\n"
                  + " Expected:\n" + _infoSchedule + "\n"
                  + " Found:\n" + _existingSchedule);
        }
        final HashMap<String, TableInfo.Column> _columnsHolidayCalendar = new HashMap<String, TableInfo.Column>(8);
        _columnsHolidayCalendar.put("umCalendarUid", new TableInfo.Column("umCalendarUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHolidayCalendar.put("umCalendarName", new TableInfo.Column("umCalendarName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHolidayCalendar.put("umCalendarCategory", new TableInfo.Column("umCalendarCategory", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHolidayCalendar.put("umCalendarActive", new TableInfo.Column("umCalendarActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHolidayCalendar.put("umCalendarMasterChangeSeqNum", new TableInfo.Column("umCalendarMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHolidayCalendar.put("umCalendarLocalChangeSeqNum", new TableInfo.Column("umCalendarLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHolidayCalendar.put("umCalendarLastChangedBy", new TableInfo.Column("umCalendarLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHolidayCalendar.put("umCalendarLct", new TableInfo.Column("umCalendarLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysHolidayCalendar = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesHolidayCalendar = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoHolidayCalendar = new TableInfo("HolidayCalendar", _columnsHolidayCalendar, _foreignKeysHolidayCalendar, _indicesHolidayCalendar);
        final TableInfo _existingHolidayCalendar = TableInfo.read(db, "HolidayCalendar");
        if (!_infoHolidayCalendar.equals(_existingHolidayCalendar)) {
          return new RoomOpenHelper.ValidationResult(false, "HolidayCalendar(com.ustadmobile.lib.db.entities.HolidayCalendar).\n"
                  + " Expected:\n" + _infoHolidayCalendar + "\n"
                  + " Found:\n" + _existingHolidayCalendar);
        }
        final HashMap<String, TableInfo.Column> _columnsHoliday = new HashMap<String, TableInfo.Column>(10);
        _columnsHoliday.put("holUid", new TableInfo.Column("holUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHoliday.put("holMasterCsn", new TableInfo.Column("holMasterCsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHoliday.put("holLocalCsn", new TableInfo.Column("holLocalCsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHoliday.put("holLastModBy", new TableInfo.Column("holLastModBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHoliday.put("holLct", new TableInfo.Column("holLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHoliday.put("holActive", new TableInfo.Column("holActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHoliday.put("holHolidayCalendarUid", new TableInfo.Column("holHolidayCalendarUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHoliday.put("holStartTime", new TableInfo.Column("holStartTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHoliday.put("holEndTime", new TableInfo.Column("holEndTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsHoliday.put("holName", new TableInfo.Column("holName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysHoliday = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesHoliday = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoHoliday = new TableInfo("Holiday", _columnsHoliday, _foreignKeysHoliday, _indicesHoliday);
        final TableInfo _existingHoliday = TableInfo.read(db, "Holiday");
        if (!_infoHoliday.equals(_existingHoliday)) {
          return new RoomOpenHelper.ValidationResult(false, "Holiday(com.ustadmobile.lib.db.entities.Holiday).\n"
                  + " Expected:\n" + _infoHoliday + "\n"
                  + " Found:\n" + _existingHoliday);
        }
        final HashMap<String, TableInfo.Column> _columnsPerson = new HashMap<String, TableInfo.Column>(25);
        _columnsPerson.put("personUid", new TableInfo.Column("personUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("username", new TableInfo.Column("username", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("firstNames", new TableInfo.Column("firstNames", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("lastName", new TableInfo.Column("lastName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("emailAddr", new TableInfo.Column("emailAddr", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("phoneNum", new TableInfo.Column("phoneNum", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("gender", new TableInfo.Column("gender", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("active", new TableInfo.Column("active", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("isPersonalAccount", new TableInfo.Column("isPersonalAccount", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("dateOfBirth", new TableInfo.Column("dateOfBirth", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("personAddress", new TableInfo.Column("personAddress", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("personOrgId", new TableInfo.Column("personOrgId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("personGroupUid", new TableInfo.Column("personGroupUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("personLct", new TableInfo.Column("personLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("personCountry", new TableInfo.Column("personCountry", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("personType", new TableInfo.Column("personType", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("personMasterChangeSeqNum", new TableInfo.Column("personMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("personLocalChangeSeqNum", new TableInfo.Column("personLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("personLastChangedBy", new TableInfo.Column("personLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("admin", new TableInfo.Column("admin", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("personNotes", new TableInfo.Column("personNotes", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("fatherName", new TableInfo.Column("fatherName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("fatherNumber", new TableInfo.Column("fatherNumber", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("motherName", new TableInfo.Column("motherName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPerson.put("motherNum", new TableInfo.Column("motherNum", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysPerson = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesPerson = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoPerson = new TableInfo("Person", _columnsPerson, _foreignKeysPerson, _indicesPerson);
        final TableInfo _existingPerson = TableInfo.read(db, "Person");
        if (!_infoPerson.equals(_existingPerson)) {
          return new RoomOpenHelper.ValidationResult(false, "Person(com.ustadmobile.lib.db.entities.Person).\n"
                  + " Expected:\n" + _infoPerson + "\n"
                  + " Found:\n" + _existingPerson);
        }
        final HashMap<String, TableInfo.Column> _columnsClazz = new HashMap<String, TableInfo.Column>(25);
        _columnsClazz.put("clazzUid", new TableInfo.Column("clazzUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzName", new TableInfo.Column("clazzName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzDesc", new TableInfo.Column("clazzDesc", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("attendanceAverage", new TableInfo.Column("attendanceAverage", "REAL", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzHolidayUMCalendarUid", new TableInfo.Column("clazzHolidayUMCalendarUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzScheuleUMCalendarUid", new TableInfo.Column("clazzScheuleUMCalendarUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("isClazzActive", new TableInfo.Column("isClazzActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzLocationUid", new TableInfo.Column("clazzLocationUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzStartTime", new TableInfo.Column("clazzStartTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzEndTime", new TableInfo.Column("clazzEndTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzFeatures", new TableInfo.Column("clazzFeatures", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzSchoolUid", new TableInfo.Column("clazzSchoolUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzEnrolmentPolicy", new TableInfo.Column("clazzEnrolmentPolicy", "INTEGER", true, 0, "102", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzTerminologyUid", new TableInfo.Column("clazzTerminologyUid", "INTEGER", true, 0, "25966", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzMasterChangeSeqNum", new TableInfo.Column("clazzMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzLocalChangeSeqNum", new TableInfo.Column("clazzLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzLastChangedBy", new TableInfo.Column("clazzLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzLct", new TableInfo.Column("clazzLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzTimeZone", new TableInfo.Column("clazzTimeZone", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzStudentsPersonGroupUid", new TableInfo.Column("clazzStudentsPersonGroupUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzTeachersPersonGroupUid", new TableInfo.Column("clazzTeachersPersonGroupUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzPendingStudentsPersonGroupUid", new TableInfo.Column("clazzPendingStudentsPersonGroupUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzParentsPersonGroupUid", new TableInfo.Column("clazzParentsPersonGroupUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzCode", new TableInfo.Column("clazzCode", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazz.put("clazzOwnerPersonUid", new TableInfo.Column("clazzOwnerPersonUid", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysClazz = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesClazz = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoClazz = new TableInfo("Clazz", _columnsClazz, _foreignKeysClazz, _indicesClazz);
        final TableInfo _existingClazz = TableInfo.read(db, "Clazz");
        if (!_infoClazz.equals(_existingClazz)) {
          return new RoomOpenHelper.ValidationResult(false, "Clazz(com.ustadmobile.lib.db.entities.Clazz).\n"
                  + " Expected:\n" + _infoClazz + "\n"
                  + " Found:\n" + _existingClazz);
        }
        final HashMap<String, TableInfo.Column> _columnsClazzEnrolment = new HashMap<String, TableInfo.Column>(15);
        _columnsClazzEnrolment.put("clazzEnrolmentUid", new TableInfo.Column("clazzEnrolmentUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentPersonUid", new TableInfo.Column("clazzEnrolmentPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentClazzUid", new TableInfo.Column("clazzEnrolmentClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentDateJoined", new TableInfo.Column("clazzEnrolmentDateJoined", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentDateLeft", new TableInfo.Column("clazzEnrolmentDateLeft", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentRole", new TableInfo.Column("clazzEnrolmentRole", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentAttendancePercentage", new TableInfo.Column("clazzEnrolmentAttendancePercentage", "REAL", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentActive", new TableInfo.Column("clazzEnrolmentActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentLeavingReasonUid", new TableInfo.Column("clazzEnrolmentLeavingReasonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentOutcome", new TableInfo.Column("clazzEnrolmentOutcome", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentLocalChangeSeqNum", new TableInfo.Column("clazzEnrolmentLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentMasterChangeSeqNum", new TableInfo.Column("clazzEnrolmentMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentLastChangedBy", new TableInfo.Column("clazzEnrolmentLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentLct", new TableInfo.Column("clazzEnrolmentLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzEnrolment.put("clazzEnrolmentInviteUid", new TableInfo.Column("clazzEnrolmentInviteUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysClazzEnrolment = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesClazzEnrolment = new HashSet<TableInfo.Index>(5);
        _indicesClazzEnrolment.add(new TableInfo.Index("index_ClazzEnrolment_clazzEnrolmentPersonUid_clazzEnrolmentClazzUid", false, Arrays.asList("clazzEnrolmentPersonUid", "clazzEnrolmentClazzUid"), Arrays.asList("ASC", "ASC")));
        _indicesClazzEnrolment.add(new TableInfo.Index("index_ClazzEnrolment_clazzEnrolmentClazzUid_clazzEnrolmentPersonUid", false, Arrays.asList("clazzEnrolmentClazzUid", "clazzEnrolmentPersonUid"), Arrays.asList("ASC", "ASC")));
        _indicesClazzEnrolment.add(new TableInfo.Index("index_ClazzEnrolment_clazzEnrolmentClazzUid_clazzEnrolmentRole", false, Arrays.asList("clazzEnrolmentClazzUid", "clazzEnrolmentRole"), Arrays.asList("ASC", "ASC")));
        _indicesClazzEnrolment.add(new TableInfo.Index("index_ClazzEnrolment_clazzEnrolmentPersonUid", false, Arrays.asList("clazzEnrolmentPersonUid"), Arrays.asList("ASC")));
        _indicesClazzEnrolment.add(new TableInfo.Index("index_ClazzEnrolment_clazzEnrolmentClazzUid", false, Arrays.asList("clazzEnrolmentClazzUid"), Arrays.asList("ASC")));
        final TableInfo _infoClazzEnrolment = new TableInfo("ClazzEnrolment", _columnsClazzEnrolment, _foreignKeysClazzEnrolment, _indicesClazzEnrolment);
        final TableInfo _existingClazzEnrolment = TableInfo.read(db, "ClazzEnrolment");
        if (!_infoClazzEnrolment.equals(_existingClazzEnrolment)) {
          return new RoomOpenHelper.ValidationResult(false, "ClazzEnrolment(com.ustadmobile.lib.db.entities.ClazzEnrolment).\n"
                  + " Expected:\n" + _infoClazzEnrolment + "\n"
                  + " Found:\n" + _existingClazzEnrolment);
        }
        final HashMap<String, TableInfo.Column> _columnsLeavingReason = new HashMap<String, TableInfo.Column>(6);
        _columnsLeavingReason.put("leavingReasonUid", new TableInfo.Column("leavingReasonUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLeavingReason.put("leavingReasonTitle", new TableInfo.Column("leavingReasonTitle", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLeavingReason.put("leavingReasonMCSN", new TableInfo.Column("leavingReasonMCSN", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLeavingReason.put("leavingReasonCSN", new TableInfo.Column("leavingReasonCSN", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLeavingReason.put("leavingReasonLCB", new TableInfo.Column("leavingReasonLCB", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLeavingReason.put("leavingReasonLct", new TableInfo.Column("leavingReasonLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysLeavingReason = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesLeavingReason = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoLeavingReason = new TableInfo("LeavingReason", _columnsLeavingReason, _foreignKeysLeavingReason, _indicesLeavingReason);
        final TableInfo _existingLeavingReason = TableInfo.read(db, "LeavingReason");
        if (!_infoLeavingReason.equals(_existingLeavingReason)) {
          return new RoomOpenHelper.ValidationResult(false, "LeavingReason(com.ustadmobile.lib.db.entities.LeavingReason).\n"
                  + " Expected:\n" + _infoLeavingReason + "\n"
                  + " Found:\n" + _existingLeavingReason);
        }
        final HashMap<String, TableInfo.Column> _columnsClazzInvite = new HashMap<String, TableInfo.Column>(10);
        _columnsClazzInvite.put("ciUid", new TableInfo.Column("ciUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzInvite.put("ciPersonUid", new TableInfo.Column("ciPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzInvite.put("ciRoleId", new TableInfo.Column("ciRoleId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzInvite.put("ciClazzUid", new TableInfo.Column("ciClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzInvite.put("inviteType", new TableInfo.Column("inviteType", "INTEGER", true, 0, "1", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzInvite.put("inviteContact", new TableInfo.Column("inviteContact", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzInvite.put("inviteToken", new TableInfo.Column("inviteToken", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzInvite.put("inviteStatus", new TableInfo.Column("inviteStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzInvite.put("inviteExpire", new TableInfo.Column("inviteExpire", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzInvite.put("inviteLct", new TableInfo.Column("inviteLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysClazzInvite = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesClazzInvite = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoClazzInvite = new TableInfo("ClazzInvite", _columnsClazzInvite, _foreignKeysClazzInvite, _indicesClazzInvite);
        final TableInfo _existingClazzInvite = TableInfo.read(db, "ClazzInvite");
        if (!_infoClazzInvite.equals(_existingClazzInvite)) {
          return new RoomOpenHelper.ValidationResult(false, "ClazzInvite(com.ustadmobile.lib.db.entities.ClazzInvite).\n"
                  + " Expected:\n" + _infoClazzInvite + "\n"
                  + " Found:\n" + _existingClazzInvite);
        }
        final HashMap<String, TableInfo.Column> _columnsContentEntry = new HashMap<String, TableInfo.Column>(27);
        _columnsContentEntry.put("contentEntryUid", new TableInfo.Column("contentEntryUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("title", new TableInfo.Column("title", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("description", new TableInfo.Column("description", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("entryId", new TableInfo.Column("entryId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("author", new TableInfo.Column("author", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("publisher", new TableInfo.Column("publisher", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("licenseType", new TableInfo.Column("licenseType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("licenseName", new TableInfo.Column("licenseName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("licenseUrl", new TableInfo.Column("licenseUrl", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("sourceUrl", new TableInfo.Column("sourceUrl", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("thumbnailUrl", new TableInfo.Column("thumbnailUrl", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("lastModified", new TableInfo.Column("lastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("primaryLanguageUid", new TableInfo.Column("primaryLanguageUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("languageVariantUid", new TableInfo.Column("languageVariantUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("contentFlags", new TableInfo.Column("contentFlags", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("leaf", new TableInfo.Column("leaf", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("publik", new TableInfo.Column("publik", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("ceInactive", new TableInfo.Column("ceInactive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("completionCriteria", new TableInfo.Column("completionCriteria", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("minScore", new TableInfo.Column("minScore", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("contentTypeFlag", new TableInfo.Column("contentTypeFlag", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("contentOwner", new TableInfo.Column("contentOwner", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("contentOwnerType", new TableInfo.Column("contentOwnerType", "INTEGER", true, 0, "1", TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("contentEntryLocalChangeSeqNum", new TableInfo.Column("contentEntryLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("contentEntryMasterChangeSeqNum", new TableInfo.Column("contentEntryMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("contentEntryLastChangedBy", new TableInfo.Column("contentEntryLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntry.put("contentEntryLct", new TableInfo.Column("contentEntryLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysContentEntry = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesContentEntry = new HashSet<TableInfo.Index>(1);
        _indicesContentEntry.add(new TableInfo.Index("index_ContentEntry_primaryLanguageUid", false, Arrays.asList("primaryLanguageUid"), Arrays.asList("ASC")));
        final TableInfo _infoContentEntry = new TableInfo("ContentEntry", _columnsContentEntry, _foreignKeysContentEntry, _indicesContentEntry);
        final TableInfo _existingContentEntry = TableInfo.read(db, "ContentEntry");
        if (!_infoContentEntry.equals(_existingContentEntry)) {
          return new RoomOpenHelper.ValidationResult(false, "ContentEntry(com.ustadmobile.lib.db.entities.ContentEntry).\n"
                  + " Expected:\n" + _infoContentEntry + "\n"
                  + " Found:\n" + _existingContentEntry);
        }
        final HashMap<String, TableInfo.Column> _columnsContentEntryContentCategoryJoin = new HashMap<String, TableInfo.Column>(7);
        _columnsContentEntryContentCategoryJoin.put("ceccjUid", new TableInfo.Column("ceccjUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryContentCategoryJoin.put("ceccjContentEntryUid", new TableInfo.Column("ceccjContentEntryUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryContentCategoryJoin.put("ceccjContentCategoryUid", new TableInfo.Column("ceccjContentCategoryUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryContentCategoryJoin.put("ceccjLocalChangeSeqNum", new TableInfo.Column("ceccjLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryContentCategoryJoin.put("ceccjMasterChangeSeqNum", new TableInfo.Column("ceccjMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryContentCategoryJoin.put("ceccjLastChangedBy", new TableInfo.Column("ceccjLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryContentCategoryJoin.put("ceccjLct", new TableInfo.Column("ceccjLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysContentEntryContentCategoryJoin = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesContentEntryContentCategoryJoin = new HashSet<TableInfo.Index>(1);
        _indicesContentEntryContentCategoryJoin.add(new TableInfo.Index("index_ContentEntryContentCategoryJoin_ceccjContentEntryUid", false, Arrays.asList("ceccjContentEntryUid"), Arrays.asList("ASC")));
        final TableInfo _infoContentEntryContentCategoryJoin = new TableInfo("ContentEntryContentCategoryJoin", _columnsContentEntryContentCategoryJoin, _foreignKeysContentEntryContentCategoryJoin, _indicesContentEntryContentCategoryJoin);
        final TableInfo _existingContentEntryContentCategoryJoin = TableInfo.read(db, "ContentEntryContentCategoryJoin");
        if (!_infoContentEntryContentCategoryJoin.equals(_existingContentEntryContentCategoryJoin)) {
          return new RoomOpenHelper.ValidationResult(false, "ContentEntryContentCategoryJoin(com.ustadmobile.lib.db.entities.ContentEntryContentCategoryJoin).\n"
                  + " Expected:\n" + _infoContentEntryContentCategoryJoin + "\n"
                  + " Found:\n" + _existingContentEntryContentCategoryJoin);
        }
        final HashMap<String, TableInfo.Column> _columnsContentEntryParentChildJoin = new HashMap<String, TableInfo.Column>(9);
        _columnsContentEntryParentChildJoin.put("cepcjParentContentEntryUid", new TableInfo.Column("cepcjParentContentEntryUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryParentChildJoin.put("cepcjChildContentEntryUid", new TableInfo.Column("cepcjChildContentEntryUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryParentChildJoin.put("childIndex", new TableInfo.Column("childIndex", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryParentChildJoin.put("cepcjUid", new TableInfo.Column("cepcjUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryParentChildJoin.put("cepcjLocalChangeSeqNum", new TableInfo.Column("cepcjLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryParentChildJoin.put("cepcjMasterChangeSeqNum", new TableInfo.Column("cepcjMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryParentChildJoin.put("cepcjLastChangedBy", new TableInfo.Column("cepcjLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryParentChildJoin.put("cepcjLct", new TableInfo.Column("cepcjLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryParentChildJoin.put("cepcjDeleted", new TableInfo.Column("cepcjDeleted", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysContentEntryParentChildJoin = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesContentEntryParentChildJoin = new HashSet<TableInfo.Index>(3);
        _indicesContentEntryParentChildJoin.add(new TableInfo.Index("parent_child", false, Arrays.asList("cepcjChildContentEntryUid", "cepcjParentContentEntryUid"), Arrays.asList("ASC", "ASC")));
        _indicesContentEntryParentChildJoin.add(new TableInfo.Index("index_ContentEntryParentChildJoin_cepcjParentContentEntryUid", false, Arrays.asList("cepcjParentContentEntryUid"), Arrays.asList("ASC")));
        _indicesContentEntryParentChildJoin.add(new TableInfo.Index("index_ContentEntryParentChildJoin_cepcjChildContentEntryUid", false, Arrays.asList("cepcjChildContentEntryUid"), Arrays.asList("ASC")));
        final TableInfo _infoContentEntryParentChildJoin = new TableInfo("ContentEntryParentChildJoin", _columnsContentEntryParentChildJoin, _foreignKeysContentEntryParentChildJoin, _indicesContentEntryParentChildJoin);
        final TableInfo _existingContentEntryParentChildJoin = TableInfo.read(db, "ContentEntryParentChildJoin");
        if (!_infoContentEntryParentChildJoin.equals(_existingContentEntryParentChildJoin)) {
          return new RoomOpenHelper.ValidationResult(false, "ContentEntryParentChildJoin(com.ustadmobile.lib.db.entities.ContentEntryParentChildJoin).\n"
                  + " Expected:\n" + _infoContentEntryParentChildJoin + "\n"
                  + " Found:\n" + _existingContentEntryParentChildJoin);
        }
        final HashMap<String, TableInfo.Column> _columnsContentEntryRelatedEntryJoin = new HashMap<String, TableInfo.Column>(10);
        _columnsContentEntryRelatedEntryJoin.put("cerejUid", new TableInfo.Column("cerejUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryRelatedEntryJoin.put("cerejContentEntryUid", new TableInfo.Column("cerejContentEntryUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryRelatedEntryJoin.put("cerejRelatedEntryUid", new TableInfo.Column("cerejRelatedEntryUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryRelatedEntryJoin.put("cerejLastChangedBy", new TableInfo.Column("cerejLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryRelatedEntryJoin.put("relType", new TableInfo.Column("relType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryRelatedEntryJoin.put("comment", new TableInfo.Column("comment", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryRelatedEntryJoin.put("cerejRelLanguageUid", new TableInfo.Column("cerejRelLanguageUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryRelatedEntryJoin.put("cerejLocalChangeSeqNum", new TableInfo.Column("cerejLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryRelatedEntryJoin.put("cerejMasterChangeSeqNum", new TableInfo.Column("cerejMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryRelatedEntryJoin.put("cerejLct", new TableInfo.Column("cerejLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysContentEntryRelatedEntryJoin = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesContentEntryRelatedEntryJoin = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoContentEntryRelatedEntryJoin = new TableInfo("ContentEntryRelatedEntryJoin", _columnsContentEntryRelatedEntryJoin, _foreignKeysContentEntryRelatedEntryJoin, _indicesContentEntryRelatedEntryJoin);
        final TableInfo _existingContentEntryRelatedEntryJoin = TableInfo.read(db, "ContentEntryRelatedEntryJoin");
        if (!_infoContentEntryRelatedEntryJoin.equals(_existingContentEntryRelatedEntryJoin)) {
          return new RoomOpenHelper.ValidationResult(false, "ContentEntryRelatedEntryJoin(com.ustadmobile.lib.db.entities.ContentEntryRelatedEntryJoin).\n"
                  + " Expected:\n" + _infoContentEntryRelatedEntryJoin + "\n"
                  + " Found:\n" + _existingContentEntryRelatedEntryJoin);
        }
        final HashMap<String, TableInfo.Column> _columnsContentCategorySchema = new HashMap<String, TableInfo.Column>(7);
        _columnsContentCategorySchema.put("contentCategorySchemaUid", new TableInfo.Column("contentCategorySchemaUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentCategorySchema.put("schemaName", new TableInfo.Column("schemaName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentCategorySchema.put("schemaUrl", new TableInfo.Column("schemaUrl", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentCategorySchema.put("contentCategorySchemaLocalChangeSeqNum", new TableInfo.Column("contentCategorySchemaLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentCategorySchema.put("contentCategorySchemaMasterChangeSeqNum", new TableInfo.Column("contentCategorySchemaMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentCategorySchema.put("contentCategorySchemaLastChangedBy", new TableInfo.Column("contentCategorySchemaLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentCategorySchema.put("contentCategorySchemaLct", new TableInfo.Column("contentCategorySchemaLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysContentCategorySchema = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesContentCategorySchema = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoContentCategorySchema = new TableInfo("ContentCategorySchema", _columnsContentCategorySchema, _foreignKeysContentCategorySchema, _indicesContentCategorySchema);
        final TableInfo _existingContentCategorySchema = TableInfo.read(db, "ContentCategorySchema");
        if (!_infoContentCategorySchema.equals(_existingContentCategorySchema)) {
          return new RoomOpenHelper.ValidationResult(false, "ContentCategorySchema(com.ustadmobile.lib.db.entities.ContentCategorySchema).\n"
                  + " Expected:\n" + _infoContentCategorySchema + "\n"
                  + " Found:\n" + _existingContentCategorySchema);
        }
        final HashMap<String, TableInfo.Column> _columnsContentCategory = new HashMap<String, TableInfo.Column>(7);
        _columnsContentCategory.put("contentCategoryUid", new TableInfo.Column("contentCategoryUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentCategory.put("ctnCatContentCategorySchemaUid", new TableInfo.Column("ctnCatContentCategorySchemaUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentCategory.put("name", new TableInfo.Column("name", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentCategory.put("contentCategoryLocalChangeSeqNum", new TableInfo.Column("contentCategoryLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentCategory.put("contentCategoryMasterChangeSeqNum", new TableInfo.Column("contentCategoryMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentCategory.put("contentCategoryLastChangedBy", new TableInfo.Column("contentCategoryLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentCategory.put("contentCategoryLct", new TableInfo.Column("contentCategoryLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysContentCategory = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesContentCategory = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoContentCategory = new TableInfo("ContentCategory", _columnsContentCategory, _foreignKeysContentCategory, _indicesContentCategory);
        final TableInfo _existingContentCategory = TableInfo.read(db, "ContentCategory");
        if (!_infoContentCategory.equals(_existingContentCategory)) {
          return new RoomOpenHelper.ValidationResult(false, "ContentCategory(com.ustadmobile.lib.db.entities.ContentCategory).\n"
                  + " Expected:\n" + _infoContentCategory + "\n"
                  + " Found:\n" + _existingContentCategory);
        }
        final HashMap<String, TableInfo.Column> _columnsLanguage = new HashMap<String, TableInfo.Column>(11);
        _columnsLanguage.put("langUid", new TableInfo.Column("langUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguage.put("name", new TableInfo.Column("name", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguage.put("iso_639_1_standard", new TableInfo.Column("iso_639_1_standard", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguage.put("iso_639_2_standard", new TableInfo.Column("iso_639_2_standard", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguage.put("iso_639_3_standard", new TableInfo.Column("iso_639_3_standard", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguage.put("Language_Type", new TableInfo.Column("Language_Type", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguage.put("languageActive", new TableInfo.Column("languageActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguage.put("langLocalChangeSeqNum", new TableInfo.Column("langLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguage.put("langMasterChangeSeqNum", new TableInfo.Column("langMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguage.put("langLastChangedBy", new TableInfo.Column("langLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguage.put("langLct", new TableInfo.Column("langLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysLanguage = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesLanguage = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoLanguage = new TableInfo("Language", _columnsLanguage, _foreignKeysLanguage, _indicesLanguage);
        final TableInfo _existingLanguage = TableInfo.read(db, "Language");
        if (!_infoLanguage.equals(_existingLanguage)) {
          return new RoomOpenHelper.ValidationResult(false, "Language(com.ustadmobile.lib.db.entities.Language).\n"
                  + " Expected:\n" + _infoLanguage + "\n"
                  + " Found:\n" + _existingLanguage);
        }
        final HashMap<String, TableInfo.Column> _columnsLanguageVariant = new HashMap<String, TableInfo.Column>(8);
        _columnsLanguageVariant.put("langVariantUid", new TableInfo.Column("langVariantUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguageVariant.put("langUid", new TableInfo.Column("langUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguageVariant.put("countryCode", new TableInfo.Column("countryCode", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguageVariant.put("name", new TableInfo.Column("name", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguageVariant.put("langVariantLocalChangeSeqNum", new TableInfo.Column("langVariantLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguageVariant.put("langVariantMasterChangeSeqNum", new TableInfo.Column("langVariantMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguageVariant.put("langVariantLastChangedBy", new TableInfo.Column("langVariantLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsLanguageVariant.put("langVariantLct", new TableInfo.Column("langVariantLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysLanguageVariant = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesLanguageVariant = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoLanguageVariant = new TableInfo("LanguageVariant", _columnsLanguageVariant, _foreignKeysLanguageVariant, _indicesLanguageVariant);
        final TableInfo _existingLanguageVariant = TableInfo.read(db, "LanguageVariant");
        if (!_infoLanguageVariant.equals(_existingLanguageVariant)) {
          return new RoomOpenHelper.ValidationResult(false, "LanguageVariant(com.ustadmobile.lib.db.entities.LanguageVariant).\n"
                  + " Expected:\n" + _infoLanguageVariant + "\n"
                  + " Found:\n" + _existingLanguageVariant);
        }
        final HashMap<String, TableInfo.Column> _columnsPersonAuth = new HashMap<String, TableInfo.Column>(3);
        _columnsPersonAuth.put("personAuthUid", new TableInfo.Column("personAuthUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonAuth.put("passwordHash", new TableInfo.Column("passwordHash", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonAuth.put("personAuthStatus", new TableInfo.Column("personAuthStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysPersonAuth = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesPersonAuth = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoPersonAuth = new TableInfo("PersonAuth", _columnsPersonAuth, _foreignKeysPersonAuth, _indicesPersonAuth);
        final TableInfo _existingPersonAuth = TableInfo.read(db, "PersonAuth");
        if (!_infoPersonAuth.equals(_existingPersonAuth)) {
          return new RoomOpenHelper.ValidationResult(false, "PersonAuth(com.ustadmobile.lib.db.entities.PersonAuth).\n"
                  + " Expected:\n" + _infoPersonAuth + "\n"
                  + " Found:\n" + _existingPersonAuth);
        }
        final HashMap<String, TableInfo.Column> _columnsPersonGroup = new HashMap<String, TableInfo.Column>(8);
        _columnsPersonGroup.put("groupUid", new TableInfo.Column("groupUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroup.put("groupMasterCsn", new TableInfo.Column("groupMasterCsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroup.put("groupLocalCsn", new TableInfo.Column("groupLocalCsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroup.put("groupLastChangedBy", new TableInfo.Column("groupLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroup.put("groupLct", new TableInfo.Column("groupLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroup.put("groupName", new TableInfo.Column("groupName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroup.put("groupActive", new TableInfo.Column("groupActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroup.put("personGroupFlag", new TableInfo.Column("personGroupFlag", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysPersonGroup = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesPersonGroup = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoPersonGroup = new TableInfo("PersonGroup", _columnsPersonGroup, _foreignKeysPersonGroup, _indicesPersonGroup);
        final TableInfo _existingPersonGroup = TableInfo.read(db, "PersonGroup");
        if (!_infoPersonGroup.equals(_existingPersonGroup)) {
          return new RoomOpenHelper.ValidationResult(false, "PersonGroup(com.ustadmobile.lib.db.entities.PersonGroup).\n"
                  + " Expected:\n" + _infoPersonGroup + "\n"
                  + " Found:\n" + _existingPersonGroup);
        }
        final HashMap<String, TableInfo.Column> _columnsPersonGroupMember = new HashMap<String, TableInfo.Column>(8);
        _columnsPersonGroupMember.put("groupMemberUid", new TableInfo.Column("groupMemberUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroupMember.put("groupMemberActive", new TableInfo.Column("groupMemberActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroupMember.put("groupMemberPersonUid", new TableInfo.Column("groupMemberPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroupMember.put("groupMemberGroupUid", new TableInfo.Column("groupMemberGroupUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroupMember.put("groupMemberMasterCsn", new TableInfo.Column("groupMemberMasterCsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroupMember.put("groupMemberLocalCsn", new TableInfo.Column("groupMemberLocalCsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroupMember.put("groupMemberLastChangedBy", new TableInfo.Column("groupMemberLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonGroupMember.put("groupMemberLct", new TableInfo.Column("groupMemberLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysPersonGroupMember = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesPersonGroupMember = new HashSet<TableInfo.Index>(2);
        _indicesPersonGroupMember.add(new TableInfo.Index("index_PersonGroupMember_groupMemberPersonUid", false, Arrays.asList("groupMemberPersonUid"), Arrays.asList("ASC")));
        _indicesPersonGroupMember.add(new TableInfo.Index("index_PersonGroupMember_groupMemberGroupUid", false, Arrays.asList("groupMemberGroupUid"), Arrays.asList("ASC")));
        final TableInfo _infoPersonGroupMember = new TableInfo("PersonGroupMember", _columnsPersonGroupMember, _foreignKeysPersonGroupMember, _indicesPersonGroupMember);
        final TableInfo _existingPersonGroupMember = TableInfo.read(db, "PersonGroupMember");
        if (!_infoPersonGroupMember.equals(_existingPersonGroupMember)) {
          return new RoomOpenHelper.ValidationResult(false, "PersonGroupMember(com.ustadmobile.lib.db.entities.PersonGroupMember).\n"
                  + " Expected:\n" + _infoPersonGroupMember + "\n"
                  + " Found:\n" + _existingPersonGroupMember);
        }
        final HashMap<String, TableInfo.Column> _columnsPersonPicture = new HashMap<String, TableInfo.Column>(6);
        _columnsPersonPicture.put("personPictureUid", new TableInfo.Column("personPictureUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPicture.put("personPictureLct", new TableInfo.Column("personPictureLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPicture.put("personPictureUri", new TableInfo.Column("personPictureUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPicture.put("personPictureThumbnailUri", new TableInfo.Column("personPictureThumbnailUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPicture.put("fileSize", new TableInfo.Column("fileSize", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPicture.put("personPictureActive", new TableInfo.Column("personPictureActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysPersonPicture = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesPersonPicture = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoPersonPicture = new TableInfo("PersonPicture", _columnsPersonPicture, _foreignKeysPersonPicture, _indicesPersonPicture);
        final TableInfo _existingPersonPicture = TableInfo.read(db, "PersonPicture");
        if (!_infoPersonPicture.equals(_existingPersonPicture)) {
          return new RoomOpenHelper.ValidationResult(false, "PersonPicture(com.ustadmobile.lib.db.entities.PersonPicture).\n"
                  + " Expected:\n" + _infoPersonPicture + "\n"
                  + " Found:\n" + _existingPersonPicture);
        }
        final HashMap<String, TableInfo.Column> _columnsVerbEntity = new HashMap<String, TableInfo.Column>(4);
        _columnsVerbEntity.put("verbUid", new TableInfo.Column("verbUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsVerbEntity.put("verbUrlId", new TableInfo.Column("verbUrlId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsVerbEntity.put("verbDeleted", new TableInfo.Column("verbDeleted", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsVerbEntity.put("verbLct", new TableInfo.Column("verbLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysVerbEntity = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesVerbEntity = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoVerbEntity = new TableInfo("VerbEntity", _columnsVerbEntity, _foreignKeysVerbEntity, _indicesVerbEntity);
        final TableInfo _existingVerbEntity = TableInfo.read(db, "VerbEntity");
        if (!_infoVerbEntity.equals(_existingVerbEntity)) {
          return new RoomOpenHelper.ValidationResult(false, "VerbEntity(com.ustadmobile.lib.db.entities.xapi.VerbEntity).\n"
                  + " Expected:\n" + _infoVerbEntity + "\n"
                  + " Found:\n" + _existingVerbEntity);
        }
        final HashMap<String, TableInfo.Column> _columnsActivityEntity = new HashMap<String, TableInfo.Column>(7);
        _columnsActivityEntity.put("actUid", new TableInfo.Column("actUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityEntity.put("actIdIri", new TableInfo.Column("actIdIri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityEntity.put("actType", new TableInfo.Column("actType", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityEntity.put("actMoreInfo", new TableInfo.Column("actMoreInfo", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityEntity.put("actInteractionType", new TableInfo.Column("actInteractionType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityEntity.put("actCorrectResponsePatterns", new TableInfo.Column("actCorrectResponsePatterns", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityEntity.put("actLct", new TableInfo.Column("actLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysActivityEntity = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesActivityEntity = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoActivityEntity = new TableInfo("ActivityEntity", _columnsActivityEntity, _foreignKeysActivityEntity, _indicesActivityEntity);
        final TableInfo _existingActivityEntity = TableInfo.read(db, "ActivityEntity");
        if (!_infoActivityEntity.equals(_existingActivityEntity)) {
          return new RoomOpenHelper.ValidationResult(false, "ActivityEntity(com.ustadmobile.lib.db.entities.xapi.ActivityEntity).\n"
                  + " Expected:\n" + _infoActivityEntity + "\n"
                  + " Found:\n" + _existingActivityEntity);
        }
        final HashMap<String, TableInfo.Column> _columnsStatementEntity = new HashMap<String, TableInfo.Column>(35);
        _columnsStatementEntity.put("statementIdHi", new TableInfo.Column("statementIdHi", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("statementIdLo", new TableInfo.Column("statementIdLo", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("statementActorPersonUid", new TableInfo.Column("statementActorPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("statementVerbUid", new TableInfo.Column("statementVerbUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("statementObjectType", new TableInfo.Column("statementObjectType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("statementObjectUid1", new TableInfo.Column("statementObjectUid1", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("statementObjectUid2", new TableInfo.Column("statementObjectUid2", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("statementActorUid", new TableInfo.Column("statementActorUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("authorityActorUid", new TableInfo.Column("authorityActorUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("teamUid", new TableInfo.Column("teamUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("resultCompletion", new TableInfo.Column("resultCompletion", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("resultSuccess", new TableInfo.Column("resultSuccess", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("resultScoreScaled", new TableInfo.Column("resultScoreScaled", "REAL", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("resultScoreRaw", new TableInfo.Column("resultScoreRaw", "REAL", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("resultScoreMin", new TableInfo.Column("resultScoreMin", "REAL", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("resultScoreMax", new TableInfo.Column("resultScoreMax", "REAL", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("resultDuration", new TableInfo.Column("resultDuration", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("resultResponse", new TableInfo.Column("resultResponse", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("timestamp", new TableInfo.Column("timestamp", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("stored", new TableInfo.Column("stored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("contextRegistrationHi", new TableInfo.Column("contextRegistrationHi", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("contextRegistrationLo", new TableInfo.Column("contextRegistrationLo", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("contextPlatform", new TableInfo.Column("contextPlatform", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("contextStatementRefIdHi", new TableInfo.Column("contextStatementRefIdHi", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("contextStatementRefIdLo", new TableInfo.Column("contextStatementRefIdLo", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("contextInstructorActorUid", new TableInfo.Column("contextInstructorActorUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("statementLct", new TableInfo.Column("statementLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("extensionProgress", new TableInfo.Column("extensionProgress", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("completionOrProgress", new TableInfo.Column("completionOrProgress", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("statementContentEntryUid", new TableInfo.Column("statementContentEntryUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("statementLearnerGroupUid", new TableInfo.Column("statementLearnerGroupUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("statementClazzUid", new TableInfo.Column("statementClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("statementCbUid", new TableInfo.Column("statementCbUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("statementDoorNode", new TableInfo.Column("statementDoorNode", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntity.put("isSubStatement", new TableInfo.Column("isSubStatement", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysStatementEntity = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesStatementEntity = new HashSet<TableInfo.Index>(3);
        _indicesStatementEntity.add(new TableInfo.Index("idx_stmt_actor_person", false, Arrays.asList("statementActorPersonUid"), Arrays.asList("ASC")));
        _indicesStatementEntity.add(new TableInfo.Index("idx_statement_clazz_person", false, Arrays.asList("statementClazzUid", "statementActorPersonUid"), Arrays.asList("ASC", "ASC")));
        _indicesStatementEntity.add(new TableInfo.Index("idx_statement_cbuid_actor", false, Arrays.asList("statementCbUid", "statementActorUid"), Arrays.asList("ASC", "ASC")));
        final TableInfo _infoStatementEntity = new TableInfo("StatementEntity", _columnsStatementEntity, _foreignKeysStatementEntity, _indicesStatementEntity);
        final TableInfo _existingStatementEntity = TableInfo.read(db, "StatementEntity");
        if (!_infoStatementEntity.equals(_existingStatementEntity)) {
          return new RoomOpenHelper.ValidationResult(false, "StatementEntity(com.ustadmobile.lib.db.entities.xapi.StatementEntity).\n"
                  + " Expected:\n" + _infoStatementEntity + "\n"
                  + " Found:\n" + _existingStatementEntity);
        }
        final HashMap<String, TableInfo.Column> _columnsActorEntity = new HashMap<String, TableInfo.Column>(11);
        _columnsActorEntity.put("actorUid", new TableInfo.Column("actorUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActorEntity.put("actorPersonUid", new TableInfo.Column("actorPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActorEntity.put("actorName", new TableInfo.Column("actorName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActorEntity.put("actorMbox", new TableInfo.Column("actorMbox", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActorEntity.put("actorMbox_sha1sum", new TableInfo.Column("actorMbox_sha1sum", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActorEntity.put("actorOpenid", new TableInfo.Column("actorOpenid", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActorEntity.put("actorAccountName", new TableInfo.Column("actorAccountName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActorEntity.put("actorAccountHomePage", new TableInfo.Column("actorAccountHomePage", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActorEntity.put("actorEtag", new TableInfo.Column("actorEtag", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActorEntity.put("actorLct", new TableInfo.Column("actorLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActorEntity.put("actorObjectType", new TableInfo.Column("actorObjectType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysActorEntity = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesActorEntity = new HashSet<TableInfo.Index>(2);
        _indicesActorEntity.add(new TableInfo.Index("idx_actorentity_uid_personuid", false, Arrays.asList("actorPersonUid"), Arrays.asList("ASC")));
        _indicesActorEntity.add(new TableInfo.Index("idx_actorentity_actorobjecttype", false, Arrays.asList("actorObjectType"), Arrays.asList("ASC")));
        final TableInfo _infoActorEntity = new TableInfo("ActorEntity", _columnsActorEntity, _foreignKeysActorEntity, _indicesActorEntity);
        final TableInfo _existingActorEntity = TableInfo.read(db, "ActorEntity");
        if (!_infoActorEntity.equals(_existingActorEntity)) {
          return new RoomOpenHelper.ValidationResult(false, "ActorEntity(com.ustadmobile.lib.db.entities.xapi.ActorEntity).\n"
                  + " Expected:\n" + _infoActorEntity + "\n"
                  + " Found:\n" + _existingActorEntity);
        }
        final HashMap<String, TableInfo.Column> _columnsSyncNode = new HashMap<String, TableInfo.Column>(1);
        _columnsSyncNode.put("nodeClientId", new TableInfo.Column("nodeClientId", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysSyncNode = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesSyncNode = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoSyncNode = new TableInfo("SyncNode", _columnsSyncNode, _foreignKeysSyncNode, _indicesSyncNode);
        final TableInfo _existingSyncNode = TableInfo.read(db, "SyncNode");
        if (!_infoSyncNode.equals(_existingSyncNode)) {
          return new RoomOpenHelper.ValidationResult(false, "SyncNode(com.ustadmobile.door.SyncNode).\n"
                  + " Expected:\n" + _infoSyncNode + "\n"
                  + " Found:\n" + _existingSyncNode);
        }
        final HashMap<String, TableInfo.Column> _columnsComments = new HashMap<String, TableInfo.Column>(11);
        _columnsComments.put("commentsUid", new TableInfo.Column("commentsUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsComments.put("commentsText", new TableInfo.Column("commentsText", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsComments.put("commentsEntityUid", new TableInfo.Column("commentsEntityUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsComments.put("commentsStatus", new TableInfo.Column("commentsStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsComments.put("commentsFromPersonUid", new TableInfo.Column("commentsFromPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsComments.put("commentsForSubmitterUid", new TableInfo.Column("commentsForSubmitterUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsComments.put("commentsFromSubmitterUid", new TableInfo.Column("commentsFromSubmitterUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsComments.put("commentsFlagged", new TableInfo.Column("commentsFlagged", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsComments.put("commentsDeleted", new TableInfo.Column("commentsDeleted", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsComments.put("commentsDateTimeAdded", new TableInfo.Column("commentsDateTimeAdded", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsComments.put("commentsLct", new TableInfo.Column("commentsLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysComments = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesComments = new HashSet<TableInfo.Index>(1);
        _indicesComments.add(new TableInfo.Index("idx_comments_entity_submitter", false, Arrays.asList("commentsEntityUid", "commentsForSubmitterUid"), Arrays.asList("ASC", "ASC")));
        final TableInfo _infoComments = new TableInfo("Comments", _columnsComments, _foreignKeysComments, _indicesComments);
        final TableInfo _existingComments = TableInfo.read(db, "Comments");
        if (!_infoComments.equals(_existingComments)) {
          return new RoomOpenHelper.ValidationResult(false, "Comments(com.ustadmobile.lib.db.entities.Comments).\n"
                  + " Expected:\n" + _infoComments + "\n"
                  + " Found:\n" + _existingComments);
        }
        final HashMap<String, TableInfo.Column> _columnsReport = new HashMap<String, TableInfo.Column>(24);
        _columnsReport.put("reportUid", new TableInfo.Column("reportUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("reportOwnerUid", new TableInfo.Column("reportOwnerUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("xAxis", new TableInfo.Column("xAxis", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("reportDateRangeSelection", new TableInfo.Column("reportDateRangeSelection", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("fromDate", new TableInfo.Column("fromDate", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("fromRelTo", new TableInfo.Column("fromRelTo", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("fromRelOffSet", new TableInfo.Column("fromRelOffSet", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("fromRelUnit", new TableInfo.Column("fromRelUnit", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("toDate", new TableInfo.Column("toDate", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("toRelTo", new TableInfo.Column("toRelTo", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("toRelOffSet", new TableInfo.Column("toRelOffSet", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("toRelUnit", new TableInfo.Column("toRelUnit", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("reportTitle", new TableInfo.Column("reportTitle", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("reportDescription", new TableInfo.Column("reportDescription", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("reportSeries", new TableInfo.Column("reportSeries", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("reportInactive", new TableInfo.Column("reportInactive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("isTemplate", new TableInfo.Column("isTemplate", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("priority", new TableInfo.Column("priority", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("reportTitleId", new TableInfo.Column("reportTitleId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("reportDescId", new TableInfo.Column("reportDescId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("reportMasterChangeSeqNum", new TableInfo.Column("reportMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("reportLocalChangeSeqNum", new TableInfo.Column("reportLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("reportLastChangedBy", new TableInfo.Column("reportLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReport.put("reportLct", new TableInfo.Column("reportLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysReport = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesReport = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoReport = new TableInfo("Report", _columnsReport, _foreignKeysReport, _indicesReport);
        final TableInfo _existingReport = TableInfo.read(db, "Report");
        if (!_infoReport.equals(_existingReport)) {
          return new RoomOpenHelper.ValidationResult(false, "Report(com.ustadmobile.lib.db.entities.Report).\n"
                  + " Expected:\n" + _infoReport + "\n"
                  + " Found:\n" + _existingReport);
        }
        final HashMap<String, TableInfo.Column> _columnsSite = new HashMap<String, TableInfo.Column>(9);
        _columnsSite.put("siteUid", new TableInfo.Column("siteUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSite.put("sitePcsn", new TableInfo.Column("sitePcsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSite.put("siteLcsn", new TableInfo.Column("siteLcsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSite.put("siteLcb", new TableInfo.Column("siteLcb", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSite.put("siteLct", new TableInfo.Column("siteLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSite.put("siteName", new TableInfo.Column("siteName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSite.put("guestLogin", new TableInfo.Column("guestLogin", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSite.put("registrationAllowed", new TableInfo.Column("registrationAllowed", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSite.put("authSalt", new TableInfo.Column("authSalt", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysSite = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesSite = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoSite = new TableInfo("Site", _columnsSite, _foreignKeysSite, _indicesSite);
        final TableInfo _existingSite = TableInfo.read(db, "Site");
        if (!_infoSite.equals(_existingSite)) {
          return new RoomOpenHelper.ValidationResult(false, "Site(com.ustadmobile.lib.db.entities.Site).\n"
                  + " Expected:\n" + _infoSite + "\n"
                  + " Found:\n" + _existingSite);
        }
        final HashMap<String, TableInfo.Column> _columnsSiteTerms = new HashMap<String, TableInfo.Column>(9);
        _columnsSiteTerms.put("sTermsUid", new TableInfo.Column("sTermsUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSiteTerms.put("termsHtml", new TableInfo.Column("termsHtml", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSiteTerms.put("sTermsLang", new TableInfo.Column("sTermsLang", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSiteTerms.put("sTermsLangUid", new TableInfo.Column("sTermsLangUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSiteTerms.put("sTermsActive", new TableInfo.Column("sTermsActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSiteTerms.put("sTermsLastChangedBy", new TableInfo.Column("sTermsLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSiteTerms.put("sTermsPrimaryCsn", new TableInfo.Column("sTermsPrimaryCsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSiteTerms.put("sTermsLocalCsn", new TableInfo.Column("sTermsLocalCsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSiteTerms.put("sTermsLct", new TableInfo.Column("sTermsLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysSiteTerms = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesSiteTerms = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoSiteTerms = new TableInfo("SiteTerms", _columnsSiteTerms, _foreignKeysSiteTerms, _indicesSiteTerms);
        final TableInfo _existingSiteTerms = TableInfo.read(db, "SiteTerms");
        if (!_infoSiteTerms.equals(_existingSiteTerms)) {
          return new RoomOpenHelper.ValidationResult(false, "SiteTerms(com.ustadmobile.lib.db.entities.SiteTerms).\n"
                  + " Expected:\n" + _infoSiteTerms + "\n"
                  + " Found:\n" + _existingSiteTerms);
        }
        final HashMap<String, TableInfo.Column> _columnsPersonParentJoin = new HashMap<String, TableInfo.Column>(14);
        _columnsPersonParentJoin.put("ppjUid", new TableInfo.Column("ppjUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonParentJoin.put("ppjPcsn", new TableInfo.Column("ppjPcsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonParentJoin.put("ppjLcsn", new TableInfo.Column("ppjLcsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonParentJoin.put("ppjLcb", new TableInfo.Column("ppjLcb", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonParentJoin.put("ppjLct", new TableInfo.Column("ppjLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonParentJoin.put("ppjParentPersonUid", new TableInfo.Column("ppjParentPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonParentJoin.put("ppjMinorPersonUid", new TableInfo.Column("ppjMinorPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonParentJoin.put("ppjRelationship", new TableInfo.Column("ppjRelationship", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonParentJoin.put("ppjEmail", new TableInfo.Column("ppjEmail", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonParentJoin.put("ppjPhone", new TableInfo.Column("ppjPhone", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonParentJoin.put("ppjInactive", new TableInfo.Column("ppjInactive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonParentJoin.put("ppjStatus", new TableInfo.Column("ppjStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonParentJoin.put("ppjApprovalTiemstamp", new TableInfo.Column("ppjApprovalTiemstamp", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonParentJoin.put("ppjApprovalIpAddr", new TableInfo.Column("ppjApprovalIpAddr", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysPersonParentJoin = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesPersonParentJoin = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoPersonParentJoin = new TableInfo("PersonParentJoin", _columnsPersonParentJoin, _foreignKeysPersonParentJoin, _indicesPersonParentJoin);
        final TableInfo _existingPersonParentJoin = TableInfo.read(db, "PersonParentJoin");
        if (!_infoPersonParentJoin.equals(_existingPersonParentJoin)) {
          return new RoomOpenHelper.ValidationResult(false, "PersonParentJoin(com.ustadmobile.lib.db.entities.PersonParentJoin).\n"
                  + " Expected:\n" + _infoPersonParentJoin + "\n"
                  + " Found:\n" + _existingPersonParentJoin);
        }
        final HashMap<String, TableInfo.Column> _columnsScopedGrant = new HashMap<String, TableInfo.Column>(11);
        _columnsScopedGrant.put("sgUid", new TableInfo.Column("sgUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsScopedGrant.put("sgPcsn", new TableInfo.Column("sgPcsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsScopedGrant.put("sgLcsn", new TableInfo.Column("sgLcsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsScopedGrant.put("sgLcb", new TableInfo.Column("sgLcb", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsScopedGrant.put("sgLct", new TableInfo.Column("sgLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsScopedGrant.put("sgTableId", new TableInfo.Column("sgTableId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsScopedGrant.put("sgEntityUid", new TableInfo.Column("sgEntityUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsScopedGrant.put("sgPermissions", new TableInfo.Column("sgPermissions", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsScopedGrant.put("sgGroupUid", new TableInfo.Column("sgGroupUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsScopedGrant.put("sgIndex", new TableInfo.Column("sgIndex", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsScopedGrant.put("sgFlags", new TableInfo.Column("sgFlags", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysScopedGrant = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesScopedGrant = new HashSet<TableInfo.Index>(2);
        _indicesScopedGrant.add(new TableInfo.Index("idx_group_to_entity", false, Arrays.asList("sgGroupUid", "sgPermissions", "sgTableId", "sgEntityUid"), Arrays.asList("ASC", "ASC", "ASC", "ASC")));
        _indicesScopedGrant.add(new TableInfo.Index("idx_entity_to_group", false, Arrays.asList("sgTableId", "sgEntityUid", "sgPermissions", "sgGroupUid"), Arrays.asList("ASC", "ASC", "ASC", "ASC")));
        final TableInfo _infoScopedGrant = new TableInfo("ScopedGrant", _columnsScopedGrant, _foreignKeysScopedGrant, _indicesScopedGrant);
        final TableInfo _existingScopedGrant = TableInfo.read(db, "ScopedGrant");
        if (!_infoScopedGrant.equals(_existingScopedGrant)) {
          return new RoomOpenHelper.ValidationResult(false, "ScopedGrant(com.ustadmobile.lib.db.entities.ScopedGrant).\n"
                  + " Expected:\n" + _infoScopedGrant + "\n"
                  + " Found:\n" + _existingScopedGrant);
        }
        final HashMap<String, TableInfo.Column> _columnsErrorReport = new HashMap<String, TableInfo.Column>(15);
        _columnsErrorReport.put("errUid", new TableInfo.Column("errUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("errPcsn", new TableInfo.Column("errPcsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("errLcsn", new TableInfo.Column("errLcsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("errLcb", new TableInfo.Column("errLcb", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("errLct", new TableInfo.Column("errLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("severity", new TableInfo.Column("severity", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("timestamp", new TableInfo.Column("timestamp", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("presenterUri", new TableInfo.Column("presenterUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("appVersion", new TableInfo.Column("appVersion", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("versionCode", new TableInfo.Column("versionCode", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("errorCode", new TableInfo.Column("errorCode", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("operatingSys", new TableInfo.Column("operatingSys", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("osVersion", new TableInfo.Column("osVersion", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("stackTrace", new TableInfo.Column("stackTrace", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsErrorReport.put("message", new TableInfo.Column("message", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysErrorReport = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesErrorReport = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoErrorReport = new TableInfo("ErrorReport", _columnsErrorReport, _foreignKeysErrorReport, _indicesErrorReport);
        final TableInfo _existingErrorReport = TableInfo.read(db, "ErrorReport");
        if (!_infoErrorReport.equals(_existingErrorReport)) {
          return new RoomOpenHelper.ValidationResult(false, "ErrorReport(com.ustadmobile.lib.db.entities.ErrorReport).\n"
                  + " Expected:\n" + _infoErrorReport + "\n"
                  + " Found:\n" + _existingErrorReport);
        }
        final HashMap<String, TableInfo.Column> _columnsClazzAssignment = new HashMap<String, TableInfo.Column>(24);
        _columnsClazzAssignment.put("caUid", new TableInfo.Column("caUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caTitle", new TableInfo.Column("caTitle", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caDescription", new TableInfo.Column("caDescription", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caGroupUid", new TableInfo.Column("caGroupUid", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caActive", new TableInfo.Column("caActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caClassCommentEnabled", new TableInfo.Column("caClassCommentEnabled", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caPrivateCommentsEnabled", new TableInfo.Column("caPrivateCommentsEnabled", "INTEGER", true, 0, "1", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caCompletionCriteria", new TableInfo.Column("caCompletionCriteria", "INTEGER", true, 0, "100", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caRequireFileSubmission", new TableInfo.Column("caRequireFileSubmission", "INTEGER", true, 0, "1", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caFileType", new TableInfo.Column("caFileType", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caSizeLimit", new TableInfo.Column("caSizeLimit", "INTEGER", true, 0, "50", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caNumberOfFiles", new TableInfo.Column("caNumberOfFiles", "INTEGER", true, 0, "1", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caSubmissionPolicy", new TableInfo.Column("caSubmissionPolicy", "INTEGER", true, 0, "1", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caMarkingType", new TableInfo.Column("caMarkingType", "INTEGER", true, 0, "1", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caRequireTextSubmission", new TableInfo.Column("caRequireTextSubmission", "INTEGER", true, 0, "1", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caTextLimitType", new TableInfo.Column("caTextLimitType", "INTEGER", true, 0, "1", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caTextLimit", new TableInfo.Column("caTextLimit", "INTEGER", true, 0, "500", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caXObjectUid", new TableInfo.Column("caXObjectUid", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caClazzUid", new TableInfo.Column("caClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caPeerReviewerCount", new TableInfo.Column("caPeerReviewerCount", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caLocalChangeSeqNum", new TableInfo.Column("caLocalChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caMasterChangeSeqNum", new TableInfo.Column("caMasterChangeSeqNum", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caLastChangedBy", new TableInfo.Column("caLastChangedBy", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsClazzAssignment.put("caLct", new TableInfo.Column("caLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysClazzAssignment = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesClazzAssignment = new HashSet<TableInfo.Index>(1);
        _indicesClazzAssignment.add(new TableInfo.Index("index_ClazzAssignment_caClazzUid", false, Arrays.asList("caClazzUid"), Arrays.asList("ASC")));
        final TableInfo _infoClazzAssignment = new TableInfo("ClazzAssignment", _columnsClazzAssignment, _foreignKeysClazzAssignment, _indicesClazzAssignment);
        final TableInfo _existingClazzAssignment = TableInfo.read(db, "ClazzAssignment");
        if (!_infoClazzAssignment.equals(_existingClazzAssignment)) {
          return new RoomOpenHelper.ValidationResult(false, "ClazzAssignment(com.ustadmobile.lib.db.entities.ClazzAssignment).\n"
                  + " Expected:\n" + _infoClazzAssignment + "\n"
                  + " Found:\n" + _existingClazzAssignment);
        }
        final HashMap<String, TableInfo.Column> _columnsCourseAssignmentSubmission = new HashMap<String, TableInfo.Column>(8);
        _columnsCourseAssignmentSubmission.put("casUid", new TableInfo.Column("casUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmission.put("casAssignmentUid", new TableInfo.Column("casAssignmentUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmission.put("casSubmitterUid", new TableInfo.Column("casSubmitterUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmission.put("casSubmitterPersonUid", new TableInfo.Column("casSubmitterPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmission.put("casText", new TableInfo.Column("casText", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmission.put("casType", new TableInfo.Column("casType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmission.put("casTimestamp", new TableInfo.Column("casTimestamp", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmission.put("casClazzUid", new TableInfo.Column("casClazzUid", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysCourseAssignmentSubmission = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesCourseAssignmentSubmission = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoCourseAssignmentSubmission = new TableInfo("CourseAssignmentSubmission", _columnsCourseAssignmentSubmission, _foreignKeysCourseAssignmentSubmission, _indicesCourseAssignmentSubmission);
        final TableInfo _existingCourseAssignmentSubmission = TableInfo.read(db, "CourseAssignmentSubmission");
        if (!_infoCourseAssignmentSubmission.equals(_existingCourseAssignmentSubmission)) {
          return new RoomOpenHelper.ValidationResult(false, "CourseAssignmentSubmission(com.ustadmobile.lib.db.entities.CourseAssignmentSubmission).\n"
                  + " Expected:\n" + _infoCourseAssignmentSubmission + "\n"
                  + " Found:\n" + _existingCourseAssignmentSubmission);
        }
        final HashMap<String, TableInfo.Column> _columnsCourseAssignmentSubmissionFile = new HashMap<String, TableInfo.Column>(11);
        _columnsCourseAssignmentSubmissionFile.put("casaUid", new TableInfo.Column("casaUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmissionFile.put("casaSubmissionUid", new TableInfo.Column("casaSubmissionUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmissionFile.put("casaSubmitterUid", new TableInfo.Column("casaSubmitterUid", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmissionFile.put("casaCaUid", new TableInfo.Column("casaCaUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmissionFile.put("casaClazzUid", new TableInfo.Column("casaClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmissionFile.put("casaMimeType", new TableInfo.Column("casaMimeType", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmissionFile.put("casaFileName", new TableInfo.Column("casaFileName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmissionFile.put("casaUri", new TableInfo.Column("casaUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmissionFile.put("casaSize", new TableInfo.Column("casaSize", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmissionFile.put("casaTimestamp", new TableInfo.Column("casaTimestamp", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentSubmissionFile.put("casaDeleted", new TableInfo.Column("casaDeleted", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysCourseAssignmentSubmissionFile = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesCourseAssignmentSubmissionFile = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoCourseAssignmentSubmissionFile = new TableInfo("CourseAssignmentSubmissionFile", _columnsCourseAssignmentSubmissionFile, _foreignKeysCourseAssignmentSubmissionFile, _indicesCourseAssignmentSubmissionFile);
        final TableInfo _existingCourseAssignmentSubmissionFile = TableInfo.read(db, "CourseAssignmentSubmissionFile");
        if (!_infoCourseAssignmentSubmissionFile.equals(_existingCourseAssignmentSubmissionFile)) {
          return new RoomOpenHelper.ValidationResult(false, "CourseAssignmentSubmissionFile(com.ustadmobile.lib.db.entities.CourseAssignmentSubmissionFile).\n"
                  + " Expected:\n" + _infoCourseAssignmentSubmissionFile + "\n"
                  + " Found:\n" + _existingCourseAssignmentSubmissionFile);
        }
        final HashMap<String, TableInfo.Column> _columnsCourseAssignmentMark = new HashMap<String, TableInfo.Column>(11);
        _columnsCourseAssignmentMark.put("camUid", new TableInfo.Column("camUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentMark.put("camAssignmentUid", new TableInfo.Column("camAssignmentUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentMark.put("camSubmitterUid", new TableInfo.Column("camSubmitterUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentMark.put("camMarkerSubmitterUid", new TableInfo.Column("camMarkerSubmitterUid", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentMark.put("camMarkerPersonUid", new TableInfo.Column("camMarkerPersonUid", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentMark.put("camMarkerComment", new TableInfo.Column("camMarkerComment", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentMark.put("camMark", new TableInfo.Column("camMark", "REAL", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentMark.put("camMaxMark", new TableInfo.Column("camMaxMark", "REAL", true, 0, "1", TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentMark.put("camPenalty", new TableInfo.Column("camPenalty", "REAL", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentMark.put("camLct", new TableInfo.Column("camLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseAssignmentMark.put("camClazzUid", new TableInfo.Column("camClazzUid", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysCourseAssignmentMark = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesCourseAssignmentMark = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoCourseAssignmentMark = new TableInfo("CourseAssignmentMark", _columnsCourseAssignmentMark, _foreignKeysCourseAssignmentMark, _indicesCourseAssignmentMark);
        final TableInfo _existingCourseAssignmentMark = TableInfo.read(db, "CourseAssignmentMark");
        if (!_infoCourseAssignmentMark.equals(_existingCourseAssignmentMark)) {
          return new RoomOpenHelper.ValidationResult(false, "CourseAssignmentMark(com.ustadmobile.lib.db.entities.CourseAssignmentMark).\n"
                  + " Expected:\n" + _infoCourseAssignmentMark + "\n"
                  + " Found:\n" + _existingCourseAssignmentMark);
        }
        final HashMap<String, TableInfo.Column> _columnsPeerReviewerAllocation = new HashMap<String, TableInfo.Column>(6);
        _columnsPeerReviewerAllocation.put("praUid", new TableInfo.Column("praUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPeerReviewerAllocation.put("praMarkerSubmitterUid", new TableInfo.Column("praMarkerSubmitterUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPeerReviewerAllocation.put("praToMarkerSubmitterUid", new TableInfo.Column("praToMarkerSubmitterUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPeerReviewerAllocation.put("praAssignmentUid", new TableInfo.Column("praAssignmentUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPeerReviewerAllocation.put("praActive", new TableInfo.Column("praActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPeerReviewerAllocation.put("praLct", new TableInfo.Column("praLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysPeerReviewerAllocation = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesPeerReviewerAllocation = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoPeerReviewerAllocation = new TableInfo("PeerReviewerAllocation", _columnsPeerReviewerAllocation, _foreignKeysPeerReviewerAllocation, _indicesPeerReviewerAllocation);
        final TableInfo _existingPeerReviewerAllocation = TableInfo.read(db, "PeerReviewerAllocation");
        if (!_infoPeerReviewerAllocation.equals(_existingPeerReviewerAllocation)) {
          return new RoomOpenHelper.ValidationResult(false, "PeerReviewerAllocation(com.ustadmobile.lib.db.entities.PeerReviewerAllocation).\n"
                  + " Expected:\n" + _infoPeerReviewerAllocation + "\n"
                  + " Found:\n" + _existingPeerReviewerAllocation);
        }
        final HashMap<String, TableInfo.Column> _columnsPersonAuth2 = new HashMap<String, TableInfo.Column>(7);
        _columnsPersonAuth2.put("pauthUid", new TableInfo.Column("pauthUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonAuth2.put("pauthMechanism", new TableInfo.Column("pauthMechanism", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonAuth2.put("pauthAuth", new TableInfo.Column("pauthAuth", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonAuth2.put("pauthLcsn", new TableInfo.Column("pauthLcsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonAuth2.put("pauthPcsn", new TableInfo.Column("pauthPcsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonAuth2.put("pauthLcb", new TableInfo.Column("pauthLcb", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonAuth2.put("pauthLct", new TableInfo.Column("pauthLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysPersonAuth2 = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesPersonAuth2 = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoPersonAuth2 = new TableInfo("PersonAuth2", _columnsPersonAuth2, _foreignKeysPersonAuth2, _indicesPersonAuth2);
        final TableInfo _existingPersonAuth2 = TableInfo.read(db, "PersonAuth2");
        if (!_infoPersonAuth2.equals(_existingPersonAuth2)) {
          return new RoomOpenHelper.ValidationResult(false, "PersonAuth2(com.ustadmobile.lib.db.entities.PersonAuth2).\n"
                  + " Expected:\n" + _infoPersonAuth2 + "\n"
                  + " Found:\n" + _existingPersonAuth2);
        }
        final HashMap<String, TableInfo.Column> _columnsUserSession = new HashMap<String, TableInfo.Column>(13);
        _columnsUserSession.put("usUid", new TableInfo.Column("usUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsUserSession.put("usPcsn", new TableInfo.Column("usPcsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsUserSession.put("usLcsn", new TableInfo.Column("usLcsn", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsUserSession.put("usLcb", new TableInfo.Column("usLcb", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsUserSession.put("usLct", new TableInfo.Column("usLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsUserSession.put("usPersonUid", new TableInfo.Column("usPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsUserSession.put("usClientNodeId", new TableInfo.Column("usClientNodeId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsUserSession.put("usStartTime", new TableInfo.Column("usStartTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsUserSession.put("usEndTime", new TableInfo.Column("usEndTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsUserSession.put("usStatus", new TableInfo.Column("usStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsUserSession.put("usReason", new TableInfo.Column("usReason", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsUserSession.put("usAuth", new TableInfo.Column("usAuth", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsUserSession.put("usSessionType", new TableInfo.Column("usSessionType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysUserSession = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesUserSession = new HashSet<TableInfo.Index>(2);
        _indicesUserSession.add(new TableInfo.Index("person_status_node_idx", false, Arrays.asList("usPersonUid", "usStatus", "usClientNodeId"), Arrays.asList("ASC", "ASC", "ASC")));
        _indicesUserSession.add(new TableInfo.Index("node_status_person_idx", false, Arrays.asList("usClientNodeId", "usStatus", "usPersonUid"), Arrays.asList("ASC", "ASC", "ASC")));
        final TableInfo _infoUserSession = new TableInfo("UserSession", _columnsUserSession, _foreignKeysUserSession, _indicesUserSession);
        final TableInfo _existingUserSession = TableInfo.read(db, "UserSession");
        if (!_infoUserSession.equals(_existingUserSession)) {
          return new RoomOpenHelper.ValidationResult(false, "UserSession(com.ustadmobile.lib.db.entities.UserSession).\n"
                  + " Expected:\n" + _infoUserSession + "\n"
                  + " Found:\n" + _existingUserSession);
        }
        final HashMap<String, TableInfo.Column> _columnsContentJob = new HashMap<String, TableInfo.Column>(8);
        _columnsContentJob.put("cjUid", new TableInfo.Column("cjUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentJob.put("toUri", new TableInfo.Column("toUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentJob.put("cjProgress", new TableInfo.Column("cjProgress", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentJob.put("cjTotal", new TableInfo.Column("cjTotal", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentJob.put("cjNotificationTitle", new TableInfo.Column("cjNotificationTitle", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentJob.put("cjIsMeteredAllowed", new TableInfo.Column("cjIsMeteredAllowed", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentJob.put("params", new TableInfo.Column("params", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentJob.put("cjLct", new TableInfo.Column("cjLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysContentJob = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesContentJob = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoContentJob = new TableInfo("ContentJob", _columnsContentJob, _foreignKeysContentJob, _indicesContentJob);
        final TableInfo _existingContentJob = TableInfo.read(db, "ContentJob");
        if (!_infoContentJob.equals(_existingContentJob)) {
          return new RoomOpenHelper.ValidationResult(false, "ContentJob(com.ustadmobile.lib.db.entities.ContentJob).\n"
                  + " Expected:\n" + _infoContentJob + "\n"
                  + " Found:\n" + _existingContentJob);
        }
        final HashMap<String, TableInfo.Column> _columnsContentEntryImportJob = new HashMap<String, TableInfo.Column>(20);
        _columnsContentEntryImportJob.put("cjiUid", new TableInfo.Column("cjiUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("sourceUri", new TableInfo.Column("sourceUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiOriginalFilename", new TableInfo.Column("cjiOriginalFilename", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiContentEntryUid", new TableInfo.Column("cjiContentEntryUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiParentContentEntryUid", new TableInfo.Column("cjiParentContentEntryUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiContentEntryVersion", new TableInfo.Column("cjiContentEntryVersion", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiItemProgress", new TableInfo.Column("cjiItemProgress", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiItemTotal", new TableInfo.Column("cjiItemTotal", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiStatus", new TableInfo.Column("cjiStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiRecursiveStatus", new TableInfo.Column("cjiRecursiveStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiPluginId", new TableInfo.Column("cjiPluginId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiParentCjiUid", new TableInfo.Column("cjiParentCjiUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiStartTime", new TableInfo.Column("cjiStartTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiFinishTime", new TableInfo.Column("cjiFinishTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiContentDeletedOnCancellation", new TableInfo.Column("cjiContentDeletedOnCancellation", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiCompressionLevel", new TableInfo.Column("cjiCompressionLevel", "INTEGER", true, 0, "3", TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiError", new TableInfo.Column("cjiError", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiErrorDismissed", new TableInfo.Column("cjiErrorDismissed", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiOwnerPersonUid", new TableInfo.Column("cjiOwnerPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryImportJob.put("cjiParams", new TableInfo.Column("cjiParams", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysContentEntryImportJob = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesContentEntryImportJob = new HashSet<TableInfo.Index>(1);
        _indicesContentEntryImportJob.add(new TableInfo.Index("index_ContentEntryImportJob_cjiContentEntryUid_cjiFinishTime", false, Arrays.asList("cjiContentEntryUid", "cjiFinishTime"), Arrays.asList("ASC", "ASC")));
        final TableInfo _infoContentEntryImportJob = new TableInfo("ContentEntryImportJob", _columnsContentEntryImportJob, _foreignKeysContentEntryImportJob, _indicesContentEntryImportJob);
        final TableInfo _existingContentEntryImportJob = TableInfo.read(db, "ContentEntryImportJob");
        if (!_infoContentEntryImportJob.equals(_existingContentEntryImportJob)) {
          return new RoomOpenHelper.ValidationResult(false, "ContentEntryImportJob(com.ustadmobile.lib.db.entities.ContentEntryImportJob).\n"
                  + " Expected:\n" + _infoContentEntryImportJob + "\n"
                  + " Found:\n" + _existingContentEntryImportJob);
        }
        final HashMap<String, TableInfo.Column> _columnsCourseBlock = new HashMap<String, TableInfo.Column>(23);
        _columnsCourseBlock.put("cbUid", new TableInfo.Column("cbUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbType", new TableInfo.Column("cbType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbIndentLevel", new TableInfo.Column("cbIndentLevel", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbModuleParentBlockUid", new TableInfo.Column("cbModuleParentBlockUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbTitle", new TableInfo.Column("cbTitle", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbDescription", new TableInfo.Column("cbDescription", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbCompletionCriteria", new TableInfo.Column("cbCompletionCriteria", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbHideUntilDate", new TableInfo.Column("cbHideUntilDate", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbDeadlineDate", new TableInfo.Column("cbDeadlineDate", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbLateSubmissionPenalty", new TableInfo.Column("cbLateSubmissionPenalty", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbGracePeriodDate", new TableInfo.Column("cbGracePeriodDate", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbMaxPoints", new TableInfo.Column("cbMaxPoints", "REAL", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbMinPoints", new TableInfo.Column("cbMinPoints", "REAL", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbIndex", new TableInfo.Column("cbIndex", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbClazzUid", new TableInfo.Column("cbClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbClazzSourcedId", new TableInfo.Column("cbClazzSourcedId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbActive", new TableInfo.Column("cbActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbHidden", new TableInfo.Column("cbHidden", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbEntityUid", new TableInfo.Column("cbEntityUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbLct", new TableInfo.Column("cbLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbSourcedId", new TableInfo.Column("cbSourcedId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbMetadata", new TableInfo.Column("cbMetadata", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlock.put("cbCreatedByAppId", new TableInfo.Column("cbCreatedByAppId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysCourseBlock = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesCourseBlock = new HashSet<TableInfo.Index>(1);
        _indicesCourseBlock.add(new TableInfo.Index("idx_courseblock_cbclazzuid", false, Arrays.asList("cbClazzUid"), Arrays.asList("ASC")));
        final TableInfo _infoCourseBlock = new TableInfo("CourseBlock", _columnsCourseBlock, _foreignKeysCourseBlock, _indicesCourseBlock);
        final TableInfo _existingCourseBlock = TableInfo.read(db, "CourseBlock");
        if (!_infoCourseBlock.equals(_existingCourseBlock)) {
          return new RoomOpenHelper.ValidationResult(false, "CourseBlock(com.ustadmobile.lib.db.entities.CourseBlock).\n"
                  + " Expected:\n" + _infoCourseBlock + "\n"
                  + " Found:\n" + _existingCourseBlock);
        }
        final HashMap<String, TableInfo.Column> _columnsCourseTerminology = new HashMap<String, TableInfo.Column>(4);
        _columnsCourseTerminology.put("ctUid", new TableInfo.Column("ctUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseTerminology.put("ctTitle", new TableInfo.Column("ctTitle", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseTerminology.put("ctTerminology", new TableInfo.Column("ctTerminology", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseTerminology.put("ctLct", new TableInfo.Column("ctLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysCourseTerminology = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesCourseTerminology = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoCourseTerminology = new TableInfo("CourseTerminology", _columnsCourseTerminology, _foreignKeysCourseTerminology, _indicesCourseTerminology);
        final TableInfo _existingCourseTerminology = TableInfo.read(db, "CourseTerminology");
        if (!_infoCourseTerminology.equals(_existingCourseTerminology)) {
          return new RoomOpenHelper.ValidationResult(false, "CourseTerminology(com.ustadmobile.lib.db.entities.CourseTerminology).\n"
                  + " Expected:\n" + _infoCourseTerminology + "\n"
                  + " Found:\n" + _existingCourseTerminology);
        }
        final HashMap<String, TableInfo.Column> _columnsCourseGroupSet = new HashMap<String, TableInfo.Column>(6);
        _columnsCourseGroupSet.put("cgsUid", new TableInfo.Column("cgsUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseGroupSet.put("cgsName", new TableInfo.Column("cgsName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseGroupSet.put("cgsTotalGroups", new TableInfo.Column("cgsTotalGroups", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseGroupSet.put("cgsActive", new TableInfo.Column("cgsActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseGroupSet.put("cgsClazzUid", new TableInfo.Column("cgsClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseGroupSet.put("cgsLct", new TableInfo.Column("cgsLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysCourseGroupSet = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesCourseGroupSet = new HashSet<TableInfo.Index>(1);
        _indicesCourseGroupSet.add(new TableInfo.Index("index_CourseGroupSet_cgsClazzUid", false, Arrays.asList("cgsClazzUid"), Arrays.asList("ASC")));
        final TableInfo _infoCourseGroupSet = new TableInfo("CourseGroupSet", _columnsCourseGroupSet, _foreignKeysCourseGroupSet, _indicesCourseGroupSet);
        final TableInfo _existingCourseGroupSet = TableInfo.read(db, "CourseGroupSet");
        if (!_infoCourseGroupSet.equals(_existingCourseGroupSet)) {
          return new RoomOpenHelper.ValidationResult(false, "CourseGroupSet(com.ustadmobile.lib.db.entities.CourseGroupSet).\n"
                  + " Expected:\n" + _infoCourseGroupSet + "\n"
                  + " Found:\n" + _existingCourseGroupSet);
        }
        final HashMap<String, TableInfo.Column> _columnsCourseGroupMember = new HashMap<String, TableInfo.Column>(5);
        _columnsCourseGroupMember.put("cgmUid", new TableInfo.Column("cgmUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseGroupMember.put("cgmSetUid", new TableInfo.Column("cgmSetUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseGroupMember.put("cgmGroupNumber", new TableInfo.Column("cgmGroupNumber", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseGroupMember.put("cgmPersonUid", new TableInfo.Column("cgmPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseGroupMember.put("cgmLct", new TableInfo.Column("cgmLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysCourseGroupMember = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesCourseGroupMember = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoCourseGroupMember = new TableInfo("CourseGroupMember", _columnsCourseGroupMember, _foreignKeysCourseGroupMember, _indicesCourseGroupMember);
        final TableInfo _existingCourseGroupMember = TableInfo.read(db, "CourseGroupMember");
        if (!_infoCourseGroupMember.equals(_existingCourseGroupMember)) {
          return new RoomOpenHelper.ValidationResult(false, "CourseGroupMember(com.ustadmobile.lib.db.entities.CourseGroupMember).\n"
                  + " Expected:\n" + _infoCourseGroupMember + "\n"
                  + " Found:\n" + _existingCourseGroupMember);
        }
        final HashMap<String, TableInfo.Column> _columnsContentEntryPicture = new HashMap<String, TableInfo.Column>(8);
        _columnsContentEntryPicture.put("cepUid", new TableInfo.Column("cepUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryPicture.put("cepContentEntryUid", new TableInfo.Column("cepContentEntryUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryPicture.put("cepUri", new TableInfo.Column("cepUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryPicture.put("cepMd5", new TableInfo.Column("cepMd5", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryPicture.put("cepFileSize", new TableInfo.Column("cepFileSize", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryPicture.put("cepTimestamp", new TableInfo.Column("cepTimestamp", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryPicture.put("cepMimeType", new TableInfo.Column("cepMimeType", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryPicture.put("cepActive", new TableInfo.Column("cepActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysContentEntryPicture = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesContentEntryPicture = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoContentEntryPicture = new TableInfo("ContentEntryPicture", _columnsContentEntryPicture, _foreignKeysContentEntryPicture, _indicesContentEntryPicture);
        final TableInfo _existingContentEntryPicture = TableInfo.read(db, "ContentEntryPicture");
        if (!_infoContentEntryPicture.equals(_existingContentEntryPicture)) {
          return new RoomOpenHelper.ValidationResult(false, "ContentEntryPicture(com.ustadmobile.lib.db.entities.ContentEntryPicture).\n"
                  + " Expected:\n" + _infoContentEntryPicture + "\n"
                  + " Found:\n" + _existingContentEntryPicture);
        }
        final HashMap<String, TableInfo.Column> _columnsActivityInteractionEntity = new HashMap<String, TableInfo.Column>(6);
        _columnsActivityInteractionEntity.put("aieActivityUid", new TableInfo.Column("aieActivityUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityInteractionEntity.put("aieHash", new TableInfo.Column("aieHash", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityInteractionEntity.put("aieProp", new TableInfo.Column("aieProp", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityInteractionEntity.put("aieId", new TableInfo.Column("aieId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityInteractionEntity.put("aieLastMod", new TableInfo.Column("aieLastMod", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityInteractionEntity.put("aieIsDeleted", new TableInfo.Column("aieIsDeleted", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysActivityInteractionEntity = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesActivityInteractionEntity = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoActivityInteractionEntity = new TableInfo("ActivityInteractionEntity", _columnsActivityInteractionEntity, _foreignKeysActivityInteractionEntity, _indicesActivityInteractionEntity);
        final TableInfo _existingActivityInteractionEntity = TableInfo.read(db, "ActivityInteractionEntity");
        if (!_infoActivityInteractionEntity.equals(_existingActivityInteractionEntity)) {
          return new RoomOpenHelper.ValidationResult(false, "ActivityInteractionEntity(com.ustadmobile.lib.db.entities.xapi.ActivityInteractionEntity).\n"
                  + " Expected:\n" + _infoActivityInteractionEntity + "\n"
                  + " Found:\n" + _existingActivityInteractionEntity);
        }
        final HashMap<String, TableInfo.Column> _columnsCoursePicture = new HashMap<String, TableInfo.Column>(5);
        _columnsCoursePicture.put("coursePictureUid", new TableInfo.Column("coursePictureUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCoursePicture.put("coursePictureLct", new TableInfo.Column("coursePictureLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCoursePicture.put("coursePictureUri", new TableInfo.Column("coursePictureUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCoursePicture.put("coursePictureThumbnailUri", new TableInfo.Column("coursePictureThumbnailUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCoursePicture.put("coursePictureActive", new TableInfo.Column("coursePictureActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysCoursePicture = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesCoursePicture = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoCoursePicture = new TableInfo("CoursePicture", _columnsCoursePicture, _foreignKeysCoursePicture, _indicesCoursePicture);
        final TableInfo _existingCoursePicture = TableInfo.read(db, "CoursePicture");
        if (!_infoCoursePicture.equals(_existingCoursePicture)) {
          return new RoomOpenHelper.ValidationResult(false, "CoursePicture(com.ustadmobile.lib.db.entities.CoursePicture).\n"
                  + " Expected:\n" + _infoCoursePicture + "\n"
                  + " Found:\n" + _existingCoursePicture);
        }
        final HashMap<String, TableInfo.Column> _columnsDiscussionPost = new HashMap<String, TableInfo.Column>(12);
        _columnsDiscussionPost.put("discussionPostUid", new TableInfo.Column("discussionPostUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDiscussionPost.put("discussionPostReplyToPostUid", new TableInfo.Column("discussionPostReplyToPostUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDiscussionPost.put("discussionPostTitle", new TableInfo.Column("discussionPostTitle", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDiscussionPost.put("discussionPostMessage", new TableInfo.Column("discussionPostMessage", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDiscussionPost.put("discussionPostStartDate", new TableInfo.Column("discussionPostStartDate", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDiscussionPost.put("discussionPostCourseBlockUid", new TableInfo.Column("discussionPostCourseBlockUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDiscussionPost.put("dpDeleted", new TableInfo.Column("dpDeleted", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDiscussionPost.put("discussionPostStartedPersonUid", new TableInfo.Column("discussionPostStartedPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDiscussionPost.put("discussionPostClazzUid", new TableInfo.Column("discussionPostClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDiscussionPost.put("discussionPostLct", new TableInfo.Column("discussionPostLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDiscussionPost.put("discussionPostVisible", new TableInfo.Column("discussionPostVisible", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDiscussionPost.put("discussionPostArchive", new TableInfo.Column("discussionPostArchive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysDiscussionPost = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesDiscussionPost = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoDiscussionPost = new TableInfo("DiscussionPost", _columnsDiscussionPost, _foreignKeysDiscussionPost, _indicesDiscussionPost);
        final TableInfo _existingDiscussionPost = TableInfo.read(db, "DiscussionPost");
        if (!_infoDiscussionPost.equals(_existingDiscussionPost)) {
          return new RoomOpenHelper.ValidationResult(false, "DiscussionPost(com.ustadmobile.lib.db.entities.DiscussionPost).\n"
                  + " Expected:\n" + _infoDiscussionPost + "\n"
                  + " Found:\n" + _existingDiscussionPost);
        }
        final HashMap<String, TableInfo.Column> _columnsExternalAppPermission = new HashMap<String, TableInfo.Column>(7);
        _columnsExternalAppPermission.put("eapUid", new TableInfo.Column("eapUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsExternalAppPermission.put("eapPersonUid", new TableInfo.Column("eapPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsExternalAppPermission.put("eapPackageId", new TableInfo.Column("eapPackageId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsExternalAppPermission.put("eapStartTime", new TableInfo.Column("eapStartTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsExternalAppPermission.put("eapExpireTime", new TableInfo.Column("eapExpireTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsExternalAppPermission.put("eapAuthToken", new TableInfo.Column("eapAuthToken", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsExternalAppPermission.put("eapAndroidAccountName", new TableInfo.Column("eapAndroidAccountName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysExternalAppPermission = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesExternalAppPermission = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoExternalAppPermission = new TableInfo("ExternalAppPermission", _columnsExternalAppPermission, _foreignKeysExternalAppPermission, _indicesExternalAppPermission);
        final TableInfo _existingExternalAppPermission = TableInfo.read(db, "ExternalAppPermission");
        if (!_infoExternalAppPermission.equals(_existingExternalAppPermission)) {
          return new RoomOpenHelper.ValidationResult(false, "ExternalAppPermission(com.ustadmobile.lib.db.entities.ExternalAppPermission).\n"
                  + " Expected:\n" + _infoExternalAppPermission + "\n"
                  + " Found:\n" + _existingExternalAppPermission);
        }
        final HashMap<String, TableInfo.Column> _columnsMessage = new HashMap<String, TableInfo.Column>(6);
        _columnsMessage.put("messageUid", new TableInfo.Column("messageUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsMessage.put("messageSenderPersonUid", new TableInfo.Column("messageSenderPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsMessage.put("messageToPersonUid", new TableInfo.Column("messageToPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsMessage.put("messageText", new TableInfo.Column("messageText", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsMessage.put("messageTimestamp", new TableInfo.Column("messageTimestamp", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsMessage.put("messageLct", new TableInfo.Column("messageLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysMessage = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesMessage = new HashSet<TableInfo.Index>(1);
        _indicesMessage.add(new TableInfo.Index("message_idx_send_to_time", false, Arrays.asList("messageSenderPersonUid", "messageToPersonUid", "messageTimestamp"), Arrays.asList("ASC", "ASC", "ASC")));
        final TableInfo _infoMessage = new TableInfo("Message", _columnsMessage, _foreignKeysMessage, _indicesMessage);
        final TableInfo _existingMessage = TableInfo.read(db, "Message");
        if (!_infoMessage.equals(_existingMessage)) {
          return new RoomOpenHelper.ValidationResult(false, "Message(com.ustadmobile.lib.db.entities.Message).\n"
                  + " Expected:\n" + _infoMessage + "\n"
                  + " Found:\n" + _existingMessage);
        }
        final HashMap<String, TableInfo.Column> _columnsStudentResult = new HashMap<String, TableInfo.Column>(21);
        _columnsStudentResult.put("srUid", new TableInfo.Column("srUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srSourcedId", new TableInfo.Column("srSourcedId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srCourseBlockUid", new TableInfo.Column("srCourseBlockUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srLineItemSourcedId", new TableInfo.Column("srLineItemSourcedId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srLineItemHref", new TableInfo.Column("srLineItemHref", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srClazzUid", new TableInfo.Column("srClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srAssignmentUid", new TableInfo.Column("srAssignmentUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srStatus", new TableInfo.Column("srStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srMetaData", new TableInfo.Column("srMetaData", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srStudentPersonUid", new TableInfo.Column("srStudentPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srStudentPersonSourcedId", new TableInfo.Column("srStudentPersonSourcedId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srStudentGroupId", new TableInfo.Column("srStudentGroupId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srMarkerPersonUid", new TableInfo.Column("srMarkerPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srMarkerGroupId", new TableInfo.Column("srMarkerGroupId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srScoreStatus", new TableInfo.Column("srScoreStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srScore", new TableInfo.Column("srScore", "REAL", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srScoreDate", new TableInfo.Column("srScoreDate", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srLastModified", new TableInfo.Column("srLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srComment", new TableInfo.Column("srComment", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srAppId", new TableInfo.Column("srAppId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStudentResult.put("srDeleted", new TableInfo.Column("srDeleted", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysStudentResult = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesStudentResult = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoStudentResult = new TableInfo("StudentResult", _columnsStudentResult, _foreignKeysStudentResult, _indicesStudentResult);
        final TableInfo _existingStudentResult = TableInfo.read(db, "StudentResult");
        if (!_infoStudentResult.equals(_existingStudentResult)) {
          return new RoomOpenHelper.ValidationResult(false, "StudentResult(com.ustadmobile.lib.db.entities.StudentResult).\n"
                  + " Expected:\n" + _infoStudentResult + "\n"
                  + " Found:\n" + _existingStudentResult);
        }
        RoomOpenHelper.ValidationResult _result;
        _result = onValidateSchema2(db);
        if (!_result.isValid) {
          return _result;
        }
        return new RoomOpenHelper.ValidationResult(true, null);
      }

      private RoomOpenHelper.ValidationResult onValidateSchema2(
          @NonNull final SupportSQLiteDatabase db) {
        final HashMap<String, TableInfo.Column> _columnsContentEntryVersion = new HashMap<String, TableInfo.Column>(11);
        _columnsContentEntryVersion.put("cevUid", new TableInfo.Column("cevUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryVersion.put("cevContentEntryUid", new TableInfo.Column("cevContentEntryUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryVersion.put("cevOpenUri", new TableInfo.Column("cevOpenUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryVersion.put("cevContentType", new TableInfo.Column("cevContentType", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryVersion.put("cevManifestUrl", new TableInfo.Column("cevManifestUrl", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryVersion.put("cevSize", new TableInfo.Column("cevSize", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryVersion.put("cevInActive", new TableInfo.Column("cevInActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryVersion.put("cevLastModified", new TableInfo.Column("cevLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryVersion.put("cevLct", new TableInfo.Column("cevLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryVersion.put("cevStorageSize", new TableInfo.Column("cevStorageSize", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryVersion.put("cevOriginalSize", new TableInfo.Column("cevOriginalSize", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysContentEntryVersion = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesContentEntryVersion = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoContentEntryVersion = new TableInfo("ContentEntryVersion", _columnsContentEntryVersion, _foreignKeysContentEntryVersion, _indicesContentEntryVersion);
        final TableInfo _existingContentEntryVersion = TableInfo.read(db, "ContentEntryVersion");
        if (!_infoContentEntryVersion.equals(_existingContentEntryVersion)) {
          return new RoomOpenHelper.ValidationResult(false, "ContentEntryVersion(com.ustadmobile.lib.db.entities.ContentEntryVersion).\n"
                  + " Expected:\n" + _infoContentEntryVersion + "\n"
                  + " Found:\n" + _existingContentEntryVersion);
        }
        final HashMap<String, TableInfo.Column> _columnsTransferJob = new HashMap<String, TableInfo.Column>(10);
        _columnsTransferJob.put("tjUid", new TableInfo.Column("tjUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJob.put("tjType", new TableInfo.Column("tjType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJob.put("tjStatus", new TableInfo.Column("tjStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJob.put("tjName", new TableInfo.Column("tjName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJob.put("tjUuid", new TableInfo.Column("tjUuid", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJob.put("tjTableId", new TableInfo.Column("tjTableId", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJob.put("tjEntityUid", new TableInfo.Column("tjEntityUid", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJob.put("tjTimeCreated", new TableInfo.Column("tjTimeCreated", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJob.put("tjCreationType", new TableInfo.Column("tjCreationType", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJob.put("tjOiUid", new TableInfo.Column("tjOiUid", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysTransferJob = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesTransferJob = new HashSet<TableInfo.Index>(1);
        _indicesTransferJob.add(new TableInfo.Index("TransferJob_idx_tjTableId_EntityUid", false, Arrays.asList("tjTableId", "tjEntityUid"), Arrays.asList("ASC", "ASC")));
        final TableInfo _infoTransferJob = new TableInfo("TransferJob", _columnsTransferJob, _foreignKeysTransferJob, _indicesTransferJob);
        final TableInfo _existingTransferJob = TableInfo.read(db, "TransferJob");
        if (!_infoTransferJob.equals(_existingTransferJob)) {
          return new RoomOpenHelper.ValidationResult(false, "TransferJob(com.ustadmobile.lib.db.entities.TransferJob).\n"
                  + " Expected:\n" + _infoTransferJob + "\n"
                  + " Found:\n" + _existingTransferJob);
        }
        final HashMap<String, TableInfo.Column> _columnsTransferJobItem = new HashMap<String, TableInfo.Column>(14);
        _columnsTransferJobItem.put("tjiUid", new TableInfo.Column("tjiUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobItem.put("tjiTjUid", new TableInfo.Column("tjiTjUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobItem.put("tjTotalSize", new TableInfo.Column("tjTotalSize", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobItem.put("tjTransferred", new TableInfo.Column("tjTransferred", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobItem.put("tjAttemptCount", new TableInfo.Column("tjAttemptCount", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobItem.put("tjiSrc", new TableInfo.Column("tjiSrc", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobItem.put("tjiDest", new TableInfo.Column("tjiDest", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobItem.put("tjiType", new TableInfo.Column("tjiType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobItem.put("tjiStatus", new TableInfo.Column("tjiStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobItem.put("tjiTableId", new TableInfo.Column("tjiTableId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobItem.put("tjiEntityUid", new TableInfo.Column("tjiEntityUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobItem.put("tjiEntityEtag", new TableInfo.Column("tjiEntityEtag", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobItem.put("tjiLockIdToRelease", new TableInfo.Column("tjiLockIdToRelease", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobItem.put("tjiPartialTmpFile", new TableInfo.Column("tjiPartialTmpFile", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysTransferJobItem = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesTransferJobItem = new HashSet<TableInfo.Index>(2);
        _indicesTransferJobItem.add(new TableInfo.Index("tji_table_entity_etag", false, Arrays.asList("tjiTableId", "tjiEntityUid", "tjiEntityEtag"), Arrays.asList("ASC", "ASC", "ASC")));
        _indicesTransferJobItem.add(new TableInfo.Index("transferjob_tjuid", false, Arrays.asList("tjiTjUid"), Arrays.asList("ASC")));
        final TableInfo _infoTransferJobItem = new TableInfo("TransferJobItem", _columnsTransferJobItem, _foreignKeysTransferJobItem, _indicesTransferJobItem);
        final TableInfo _existingTransferJobItem = TableInfo.read(db, "TransferJobItem");
        if (!_infoTransferJobItem.equals(_existingTransferJobItem)) {
          return new RoomOpenHelper.ValidationResult(false, "TransferJobItem(com.ustadmobile.lib.db.entities.TransferJobItem).\n"
                  + " Expected:\n" + _infoTransferJobItem + "\n"
                  + " Found:\n" + _existingTransferJobItem);
        }
        final HashMap<String, TableInfo.Column> _columnsCacheLockJoin = new HashMap<String, TableInfo.Column>(8);
        _columnsCacheLockJoin.put("cljId", new TableInfo.Column("cljId", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCacheLockJoin.put("cljTableId", new TableInfo.Column("cljTableId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCacheLockJoin.put("cljEntityUid", new TableInfo.Column("cljEntityUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCacheLockJoin.put("cljUrl", new TableInfo.Column("cljUrl", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCacheLockJoin.put("cljLockId", new TableInfo.Column("cljLockId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCacheLockJoin.put("cljStatus", new TableInfo.Column("cljStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCacheLockJoin.put("cljType", new TableInfo.Column("cljType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCacheLockJoin.put("cljOiUid", new TableInfo.Column("cljOiUid", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysCacheLockJoin = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesCacheLockJoin = new HashSet<TableInfo.Index>(2);
        _indicesCacheLockJoin.add(new TableInfo.Index("idx_clj_table_entity_url", false, Arrays.asList("cljTableId", "cljEntityUid", "cljUrl"), Arrays.asList("ASC", "ASC", "ASC")));
        _indicesCacheLockJoin.add(new TableInfo.Index("idx_clj_offline_item_uid", false, Arrays.asList("cljOiUid"), Arrays.asList("ASC")));
        final TableInfo _infoCacheLockJoin = new TableInfo("CacheLockJoin", _columnsCacheLockJoin, _foreignKeysCacheLockJoin, _indicesCacheLockJoin);
        final TableInfo _existingCacheLockJoin = TableInfo.read(db, "CacheLockJoin");
        if (!_infoCacheLockJoin.equals(_existingCacheLockJoin)) {
          return new RoomOpenHelper.ValidationResult(false, "CacheLockJoin(com.ustadmobile.lib.db.entities.CacheLockJoin).\n"
                  + " Expected:\n" + _infoCacheLockJoin + "\n"
                  + " Found:\n" + _existingCacheLockJoin);
        }
        final HashMap<String, TableInfo.Column> _columnsOfflineItem = new HashMap<String, TableInfo.Column>(7);
        _columnsOfflineItem.put("oiUid", new TableInfo.Column("oiUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOfflineItem.put("oiNodeId", new TableInfo.Column("oiNodeId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOfflineItem.put("oiClazzUid", new TableInfo.Column("oiClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOfflineItem.put("oiCourseBlockUid", new TableInfo.Column("oiCourseBlockUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOfflineItem.put("oiContentEntryUid", new TableInfo.Column("oiContentEntryUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOfflineItem.put("oiActive", new TableInfo.Column("oiActive", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOfflineItem.put("oiLct", new TableInfo.Column("oiLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysOfflineItem = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesOfflineItem = new HashSet<TableInfo.Index>(1);
        _indicesOfflineItem.add(new TableInfo.Index("offline_item_node_content_entry", false, Arrays.asList("oiNodeId", "oiContentEntryUid"), Arrays.asList("ASC", "ASC")));
        final TableInfo _infoOfflineItem = new TableInfo("OfflineItem", _columnsOfflineItem, _foreignKeysOfflineItem, _indicesOfflineItem);
        final TableInfo _existingOfflineItem = TableInfo.read(db, "OfflineItem");
        if (!_infoOfflineItem.equals(_existingOfflineItem)) {
          return new RoomOpenHelper.ValidationResult(false, "OfflineItem(com.ustadmobile.lib.db.entities.OfflineItem).\n"
                  + " Expected:\n" + _infoOfflineItem + "\n"
                  + " Found:\n" + _existingOfflineItem);
        }
        final HashMap<String, TableInfo.Column> _columnsOfflineItemPendingTransferJob = new HashMap<String, TableInfo.Column>(6);
        _columnsOfflineItemPendingTransferJob.put("oiptjId", new TableInfo.Column("oiptjId", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOfflineItemPendingTransferJob.put("oiptjOiUid", new TableInfo.Column("oiptjOiUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOfflineItemPendingTransferJob.put("oiptjTableId", new TableInfo.Column("oiptjTableId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOfflineItemPendingTransferJob.put("oiptjEntityUid", new TableInfo.Column("oiptjEntityUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOfflineItemPendingTransferJob.put("oiptjUrl", new TableInfo.Column("oiptjUrl", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOfflineItemPendingTransferJob.put("oiptjType", new TableInfo.Column("oiptjType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysOfflineItemPendingTransferJob = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesOfflineItemPendingTransferJob = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoOfflineItemPendingTransferJob = new TableInfo("OfflineItemPendingTransferJob", _columnsOfflineItemPendingTransferJob, _foreignKeysOfflineItemPendingTransferJob, _indicesOfflineItemPendingTransferJob);
        final TableInfo _existingOfflineItemPendingTransferJob = TableInfo.read(db, "OfflineItemPendingTransferJob");
        if (!_infoOfflineItemPendingTransferJob.equals(_existingOfflineItemPendingTransferJob)) {
          return new RoomOpenHelper.ValidationResult(false, "OfflineItemPendingTransferJob(com.ustadmobile.core.db.dao.OfflineItemPendingTransferJob).\n"
                  + " Expected:\n" + _infoOfflineItemPendingTransferJob + "\n"
                  + " Found:\n" + _existingOfflineItemPendingTransferJob);
        }
        final HashMap<String, TableInfo.Column> _columnsDeletedItem = new HashMap<String, TableInfo.Column>(10);
        _columnsDeletedItem.put("delItemUid", new TableInfo.Column("delItemUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDeletedItem.put("delItemName", new TableInfo.Column("delItemName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDeletedItem.put("delItemIconUri", new TableInfo.Column("delItemIconUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDeletedItem.put("delItemLastModTime", new TableInfo.Column("delItemLastModTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDeletedItem.put("delItemTimeDeleted", new TableInfo.Column("delItemTimeDeleted", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDeletedItem.put("delItemEntityTable", new TableInfo.Column("delItemEntityTable", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDeletedItem.put("delItemEntityUid", new TableInfo.Column("delItemEntityUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDeletedItem.put("delItemDeletedByPersonUid", new TableInfo.Column("delItemDeletedByPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDeletedItem.put("delItemStatus", new TableInfo.Column("delItemStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDeletedItem.put("delItemIsFolder", new TableInfo.Column("delItemIsFolder", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysDeletedItem = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesDeletedItem = new HashSet<TableInfo.Index>(1);
        _indicesDeletedItem.add(new TableInfo.Index("delitem_idx_status_time", false, Arrays.asList("delItemStatus", "delItemTimeDeleted"), Arrays.asList("ASC", "ASC")));
        final TableInfo _infoDeletedItem = new TableInfo("DeletedItem", _columnsDeletedItem, _foreignKeysDeletedItem, _indicesDeletedItem);
        final TableInfo _existingDeletedItem = TableInfo.read(db, "DeletedItem");
        if (!_infoDeletedItem.equals(_existingDeletedItem)) {
          return new RoomOpenHelper.ValidationResult(false, "DeletedItem(com.ustadmobile.lib.db.entities.DeletedItem).\n"
                  + " Expected:\n" + _infoDeletedItem + "\n"
                  + " Found:\n" + _existingDeletedItem);
        }
        final HashMap<String, TableInfo.Column> _columnsEnrolmentRequest = new HashMap<String, TableInfo.Column>(14);
        _columnsEnrolmentRequest.put("erUid", new TableInfo.Column("erUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsEnrolmentRequest.put("erClazzUid", new TableInfo.Column("erClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsEnrolmentRequest.put("erClazzName", new TableInfo.Column("erClazzName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsEnrolmentRequest.put("erPersonUid", new TableInfo.Column("erPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsEnrolmentRequest.put("erPersonFullname", new TableInfo.Column("erPersonFullname", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsEnrolmentRequest.put("erPersonPictureUri", new TableInfo.Column("erPersonPictureUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsEnrolmentRequest.put("erPersonUsername", new TableInfo.Column("erPersonUsername", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsEnrolmentRequest.put("erRole", new TableInfo.Column("erRole", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsEnrolmentRequest.put("erRequestTime", new TableInfo.Column("erRequestTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsEnrolmentRequest.put("erStatus", new TableInfo.Column("erStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsEnrolmentRequest.put("erStatusSetByPersonUid", new TableInfo.Column("erStatusSetByPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsEnrolmentRequest.put("erDeleted", new TableInfo.Column("erDeleted", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsEnrolmentRequest.put("erStatusSetAuth", new TableInfo.Column("erStatusSetAuth", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsEnrolmentRequest.put("erLastModified", new TableInfo.Column("erLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysEnrolmentRequest = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesEnrolmentRequest = new HashSet<TableInfo.Index>(2);
        _indicesEnrolmentRequest.add(new TableInfo.Index("idx_enrolmentrequest_by_clazz", false, Arrays.asList("erClazzUid", "erStatus"), Arrays.asList("ASC", "ASC")));
        _indicesEnrolmentRequest.add(new TableInfo.Index("idx_enrolmentrequest_by_person", false, Arrays.asList("erPersonUid", "erStatus"), Arrays.asList("ASC", "ASC")));
        final TableInfo _infoEnrolmentRequest = new TableInfo("EnrolmentRequest", _columnsEnrolmentRequest, _foreignKeysEnrolmentRequest, _indicesEnrolmentRequest);
        final TableInfo _existingEnrolmentRequest = TableInfo.read(db, "EnrolmentRequest");
        if (!_infoEnrolmentRequest.equals(_existingEnrolmentRequest)) {
          return new RoomOpenHelper.ValidationResult(false, "EnrolmentRequest(com.ustadmobile.lib.db.entities.EnrolmentRequest).\n"
                  + " Expected:\n" + _infoEnrolmentRequest + "\n"
                  + " Found:\n" + _existingEnrolmentRequest);
        }
        final HashMap<String, TableInfo.Column> _columnsCoursePermission = new HashMap<String, TableInfo.Column>(8);
        _columnsCoursePermission.put("cpUid", new TableInfo.Column("cpUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCoursePermission.put("cpLastModified", new TableInfo.Column("cpLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCoursePermission.put("cpClazzUid", new TableInfo.Column("cpClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCoursePermission.put("cpToEnrolmentRole", new TableInfo.Column("cpToEnrolmentRole", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCoursePermission.put("cpToPersonUid", new TableInfo.Column("cpToPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCoursePermission.put("cpToGroupUid", new TableInfo.Column("cpToGroupUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCoursePermission.put("cpPermissionsFlag", new TableInfo.Column("cpPermissionsFlag", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCoursePermission.put("cpIsDeleted", new TableInfo.Column("cpIsDeleted", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysCoursePermission = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesCoursePermission = new HashSet<TableInfo.Index>(1);
        _indicesCoursePermission.add(new TableInfo.Index("idx_coursepermission_clazzuid", false, Arrays.asList("cpClazzUid"), Arrays.asList("ASC")));
        final TableInfo _infoCoursePermission = new TableInfo("CoursePermission", _columnsCoursePermission, _foreignKeysCoursePermission, _indicesCoursePermission);
        final TableInfo _existingCoursePermission = TableInfo.read(db, "CoursePermission");
        if (!_infoCoursePermission.equals(_existingCoursePermission)) {
          return new RoomOpenHelper.ValidationResult(false, "CoursePermission(com.ustadmobile.lib.db.entities.CoursePermission).\n"
                  + " Expected:\n" + _infoCoursePermission + "\n"
                  + " Found:\n" + _existingCoursePermission);
        }
        final HashMap<String, TableInfo.Column> _columnsSystemPermission = new HashMap<String, TableInfo.Column>(6);
        _columnsSystemPermission.put("spUid", new TableInfo.Column("spUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSystemPermission.put("spToPersonUid", new TableInfo.Column("spToPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSystemPermission.put("spToGroupUid", new TableInfo.Column("spToGroupUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSystemPermission.put("spPermissionsFlag", new TableInfo.Column("spPermissionsFlag", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSystemPermission.put("spLastModified", new TableInfo.Column("spLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsSystemPermission.put("spIsDeleted", new TableInfo.Column("spIsDeleted", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysSystemPermission = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesSystemPermission = new HashSet<TableInfo.Index>(1);
        _indicesSystemPermission.add(new TableInfo.Index("idx_systempermission_personuid", false, Arrays.asList("spToPersonUid"), Arrays.asList("ASC")));
        final TableInfo _infoSystemPermission = new TableInfo("SystemPermission", _columnsSystemPermission, _foreignKeysSystemPermission, _indicesSystemPermission);
        final TableInfo _existingSystemPermission = TableInfo.read(db, "SystemPermission");
        if (!_infoSystemPermission.equals(_existingSystemPermission)) {
          return new RoomOpenHelper.ValidationResult(false, "SystemPermission(com.ustadmobile.lib.db.entities.SystemPermission).\n"
                  + " Expected:\n" + _infoSystemPermission + "\n"
                  + " Found:\n" + _existingSystemPermission);
        }
        final HashMap<String, TableInfo.Column> _columnsCourseBlockPicture = new HashMap<String, TableInfo.Column>(4);
        _columnsCourseBlockPicture.put("cbpUid", new TableInfo.Column("cbpUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlockPicture.put("cbpLct", new TableInfo.Column("cbpLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlockPicture.put("cbpPictureUri", new TableInfo.Column("cbpPictureUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsCourseBlockPicture.put("cbpThumbnailUri", new TableInfo.Column("cbpThumbnailUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysCourseBlockPicture = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesCourseBlockPicture = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoCourseBlockPicture = new TableInfo("CourseBlockPicture", _columnsCourseBlockPicture, _foreignKeysCourseBlockPicture, _indicesCourseBlockPicture);
        final TableInfo _existingCourseBlockPicture = TableInfo.read(db, "CourseBlockPicture");
        if (!_infoCourseBlockPicture.equals(_existingCourseBlockPicture)) {
          return new RoomOpenHelper.ValidationResult(false, "CourseBlockPicture(com.ustadmobile.lib.db.entities.CourseBlockPicture).\n"
                  + " Expected:\n" + _infoCourseBlockPicture + "\n"
                  + " Found:\n" + _existingCourseBlockPicture);
        }
        final HashMap<String, TableInfo.Column> _columnsContentEntryPicture2 = new HashMap<String, TableInfo.Column>(4);
        _columnsContentEntryPicture2.put("cepUid", new TableInfo.Column("cepUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryPicture2.put("cepLct", new TableInfo.Column("cepLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryPicture2.put("cepPictureUri", new TableInfo.Column("cepPictureUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsContentEntryPicture2.put("cepThumbnailUri", new TableInfo.Column("cepThumbnailUri", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysContentEntryPicture2 = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesContentEntryPicture2 = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoContentEntryPicture2 = new TableInfo("ContentEntryPicture2", _columnsContentEntryPicture2, _foreignKeysContentEntryPicture2, _indicesContentEntryPicture2);
        final TableInfo _existingContentEntryPicture2 = TableInfo.read(db, "ContentEntryPicture2");
        if (!_infoContentEntryPicture2.equals(_existingContentEntryPicture2)) {
          return new RoomOpenHelper.ValidationResult(false, "ContentEntryPicture2(com.ustadmobile.lib.db.entities.ContentEntryPicture2).\n"
                  + " Expected:\n" + _infoContentEntryPicture2 + "\n"
                  + " Found:\n" + _existingContentEntryPicture2);
        }
        final HashMap<String, TableInfo.Column> _columnsTransferJobError = new HashMap<String, TableInfo.Column>(5);
        _columnsTransferJobError.put("tjeId", new TableInfo.Column("tjeId", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobError.put("tjeTjUid", new TableInfo.Column("tjeTjUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobError.put("tjeTime", new TableInfo.Column("tjeTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobError.put("tjeErrorStr", new TableInfo.Column("tjeErrorStr", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsTransferJobError.put("tjeDismissed", new TableInfo.Column("tjeDismissed", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysTransferJobError = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesTransferJobError = new HashSet<TableInfo.Index>(1);
        _indicesTransferJobError.add(new TableInfo.Index("idx_transferjoberror_tjetjuid", false, Arrays.asList("tjeTjUid"), Arrays.asList("ASC")));
        final TableInfo _infoTransferJobError = new TableInfo("TransferJobError", _columnsTransferJobError, _foreignKeysTransferJobError, _indicesTransferJobError);
        final TableInfo _existingTransferJobError = TableInfo.read(db, "TransferJobError");
        if (!_infoTransferJobError.equals(_existingTransferJobError)) {
          return new RoomOpenHelper.ValidationResult(false, "TransferJobError(com.ustadmobile.lib.db.entities.TransferJobError).\n"
                  + " Expected:\n" + _infoTransferJobError + "\n"
                  + " Found:\n" + _existingTransferJobError);
        }
        final HashMap<String, TableInfo.Column> _columnsVerbLangMapEntry = new HashMap<String, TableInfo.Column>(5);
        _columnsVerbLangMapEntry.put("vlmeVerbUid", new TableInfo.Column("vlmeVerbUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsVerbLangMapEntry.put("vlmeLangHash", new TableInfo.Column("vlmeLangHash", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsVerbLangMapEntry.put("vlmeLangCode", new TableInfo.Column("vlmeLangCode", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsVerbLangMapEntry.put("vlmeEntryString", new TableInfo.Column("vlmeEntryString", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsVerbLangMapEntry.put("vlmeLastModified", new TableInfo.Column("vlmeLastModified", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysVerbLangMapEntry = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesVerbLangMapEntry = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoVerbLangMapEntry = new TableInfo("VerbLangMapEntry", _columnsVerbLangMapEntry, _foreignKeysVerbLangMapEntry, _indicesVerbLangMapEntry);
        final TableInfo _existingVerbLangMapEntry = TableInfo.read(db, "VerbLangMapEntry");
        if (!_infoVerbLangMapEntry.equals(_existingVerbLangMapEntry)) {
          return new RoomOpenHelper.ValidationResult(false, "VerbLangMapEntry(com.ustadmobile.lib.db.entities.xapi.VerbLangMapEntry).\n"
                  + " Expected:\n" + _infoVerbLangMapEntry + "\n"
                  + " Found:\n" + _existingVerbLangMapEntry);
        }
        final HashMap<String, TableInfo.Column> _columnsGroupMemberActorJoin = new HashMap<String, TableInfo.Column>(3);
        _columnsGroupMemberActorJoin.put("gmajGroupActorUid", new TableInfo.Column("gmajGroupActorUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsGroupMemberActorJoin.put("gmajMemberActorUid", new TableInfo.Column("gmajMemberActorUid", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsGroupMemberActorJoin.put("gmajLastMod", new TableInfo.Column("gmajLastMod", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysGroupMemberActorJoin = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesGroupMemberActorJoin = new HashSet<TableInfo.Index>(2);
        _indicesGroupMemberActorJoin.add(new TableInfo.Index("idx_groupmemberactorjoin_gmajgroupactoruid", false, Arrays.asList("gmajGroupActorUid"), Arrays.asList("ASC")));
        _indicesGroupMemberActorJoin.add(new TableInfo.Index("idx_groupmemberactorjoin_gmajmemberactoruid", false, Arrays.asList("gmajMemberActorUid"), Arrays.asList("ASC")));
        final TableInfo _infoGroupMemberActorJoin = new TableInfo("GroupMemberActorJoin", _columnsGroupMemberActorJoin, _foreignKeysGroupMemberActorJoin, _indicesGroupMemberActorJoin);
        final TableInfo _existingGroupMemberActorJoin = TableInfo.read(db, "GroupMemberActorJoin");
        if (!_infoGroupMemberActorJoin.equals(_existingGroupMemberActorJoin)) {
          return new RoomOpenHelper.ValidationResult(false, "GroupMemberActorJoin(com.ustadmobile.lib.db.entities.xapi.GroupMemberActorJoin).\n"
                  + " Expected:\n" + _infoGroupMemberActorJoin + "\n"
                  + " Found:\n" + _existingGroupMemberActorJoin);
        }
        final HashMap<String, TableInfo.Column> _columnsActivityLangMapEntry = new HashMap<String, TableInfo.Column>(7);
        _columnsActivityLangMapEntry.put("almeActivityUid", new TableInfo.Column("almeActivityUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityLangMapEntry.put("almeHash", new TableInfo.Column("almeHash", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityLangMapEntry.put("almeLangCode", new TableInfo.Column("almeLangCode", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityLangMapEntry.put("almePropName", new TableInfo.Column("almePropName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityLangMapEntry.put("almeValue", new TableInfo.Column("almeValue", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityLangMapEntry.put("almeAieHash", new TableInfo.Column("almeAieHash", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityLangMapEntry.put("almeLastMod", new TableInfo.Column("almeLastMod", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysActivityLangMapEntry = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesActivityLangMapEntry = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoActivityLangMapEntry = new TableInfo("ActivityLangMapEntry", _columnsActivityLangMapEntry, _foreignKeysActivityLangMapEntry, _indicesActivityLangMapEntry);
        final TableInfo _existingActivityLangMapEntry = TableInfo.read(db, "ActivityLangMapEntry");
        if (!_infoActivityLangMapEntry.equals(_existingActivityLangMapEntry)) {
          return new RoomOpenHelper.ValidationResult(false, "ActivityLangMapEntry(com.ustadmobile.lib.db.entities.xapi.ActivityLangMapEntry).\n"
                  + " Expected:\n" + _infoActivityLangMapEntry + "\n"
                  + " Found:\n" + _existingActivityLangMapEntry);
        }
        final HashMap<String, TableInfo.Column> _columnsActivityExtensionEntity = new HashMap<String, TableInfo.Column>(6);
        _columnsActivityExtensionEntity.put("aeeActivityUid", new TableInfo.Column("aeeActivityUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityExtensionEntity.put("aeeKeyHash", new TableInfo.Column("aeeKeyHash", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityExtensionEntity.put("aeeKey", new TableInfo.Column("aeeKey", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityExtensionEntity.put("aeeJson", new TableInfo.Column("aeeJson", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityExtensionEntity.put("aeeLastMod", new TableInfo.Column("aeeLastMod", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsActivityExtensionEntity.put("aeeIsDeleted", new TableInfo.Column("aeeIsDeleted", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysActivityExtensionEntity = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesActivityExtensionEntity = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoActivityExtensionEntity = new TableInfo("ActivityExtensionEntity", _columnsActivityExtensionEntity, _foreignKeysActivityExtensionEntity, _indicesActivityExtensionEntity);
        final TableInfo _existingActivityExtensionEntity = TableInfo.read(db, "ActivityExtensionEntity");
        if (!_infoActivityExtensionEntity.equals(_existingActivityExtensionEntity)) {
          return new RoomOpenHelper.ValidationResult(false, "ActivityExtensionEntity(com.ustadmobile.lib.db.entities.xapi.ActivityExtensionEntity).\n"
                  + " Expected:\n" + _infoActivityExtensionEntity + "\n"
                  + " Found:\n" + _existingActivityExtensionEntity);
        }
        final HashMap<String, TableInfo.Column> _columnsStatementContextActivityJoin = new HashMap<String, TableInfo.Column>(7);
        _columnsStatementContextActivityJoin.put("scajFromStatementIdHi", new TableInfo.Column("scajFromStatementIdHi", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementContextActivityJoin.put("scajFromStatementIdLo", new TableInfo.Column("scajFromStatementIdLo", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementContextActivityJoin.put("scajToHash", new TableInfo.Column("scajToHash", "INTEGER", true, 3, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementContextActivityJoin.put("scajContextType", new TableInfo.Column("scajContextType", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementContextActivityJoin.put("scajToActivityUid", new TableInfo.Column("scajToActivityUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementContextActivityJoin.put("scajToActivityId", new TableInfo.Column("scajToActivityId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementContextActivityJoin.put("scajEtag", new TableInfo.Column("scajEtag", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysStatementContextActivityJoin = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesStatementContextActivityJoin = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoStatementContextActivityJoin = new TableInfo("StatementContextActivityJoin", _columnsStatementContextActivityJoin, _foreignKeysStatementContextActivityJoin, _indicesStatementContextActivityJoin);
        final TableInfo _existingStatementContextActivityJoin = TableInfo.read(db, "StatementContextActivityJoin");
        if (!_infoStatementContextActivityJoin.equals(_existingStatementContextActivityJoin)) {
          return new RoomOpenHelper.ValidationResult(false, "StatementContextActivityJoin(com.ustadmobile.lib.db.entities.xapi.StatementContextActivityJoin).\n"
                  + " Expected:\n" + _infoStatementContextActivityJoin + "\n"
                  + " Found:\n" + _existingStatementContextActivityJoin);
        }
        final HashMap<String, TableInfo.Column> _columnsXapiSessionEntity = new HashMap<String, TableInfo.Column>(19);
        _columnsXapiSessionEntity.put("xseUid", new TableInfo.Column("xseUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseLastMod", new TableInfo.Column("xseLastMod", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseRegistrationHi", new TableInfo.Column("xseRegistrationHi", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseRegistrationLo", new TableInfo.Column("xseRegistrationLo", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseUsUid", new TableInfo.Column("xseUsUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseAccountPersonUid", new TableInfo.Column("xseAccountPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseActorUid", new TableInfo.Column("xseActorUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseAccountUsername", new TableInfo.Column("xseAccountUsername", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseClazzUid", new TableInfo.Column("xseClazzUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseCbUid", new TableInfo.Column("xseCbUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseContentEntryUid", new TableInfo.Column("xseContentEntryUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseContentEntryVersionUid", new TableInfo.Column("xseContentEntryVersionUid", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseRootActivityId", new TableInfo.Column("xseRootActivityId", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseRootActivityUid", new TableInfo.Column("xseRootActivityUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseStartTime", new TableInfo.Column("xseStartTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseExpireTime", new TableInfo.Column("xseExpireTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseAuth", new TableInfo.Column("xseAuth", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("xseCompleted", new TableInfo.Column("xseCompleted", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsXapiSessionEntity.put("knownActorUidToPersonUids", new TableInfo.Column("knownActorUidToPersonUids", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysXapiSessionEntity = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesXapiSessionEntity = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoXapiSessionEntity = new TableInfo("XapiSessionEntity", _columnsXapiSessionEntity, _foreignKeysXapiSessionEntity, _indicesXapiSessionEntity);
        final TableInfo _existingXapiSessionEntity = TableInfo.read(db, "XapiSessionEntity");
        if (!_infoXapiSessionEntity.equals(_existingXapiSessionEntity)) {
          return new RoomOpenHelper.ValidationResult(false, "XapiSessionEntity(com.ustadmobile.lib.db.entities.xapi.XapiSessionEntity).\n"
                  + " Expected:\n" + _infoXapiSessionEntity + "\n"
                  + " Found:\n" + _existingXapiSessionEntity);
        }
        final HashMap<String, TableInfo.Column> _columnsStatementEntityJson = new HashMap<String, TableInfo.Column>(4);
        _columnsStatementEntityJson.put("stmtJsonIdHi", new TableInfo.Column("stmtJsonIdHi", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntityJson.put("stmtJsonIdLo", new TableInfo.Column("stmtJsonIdLo", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntityJson.put("stmtEtag", new TableInfo.Column("stmtEtag", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStatementEntityJson.put("fullStatement", new TableInfo.Column("fullStatement", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysStatementEntityJson = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesStatementEntityJson = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoStatementEntityJson = new TableInfo("StatementEntityJson", _columnsStatementEntityJson, _foreignKeysStatementEntityJson, _indicesStatementEntityJson);
        final TableInfo _existingStatementEntityJson = TableInfo.read(db, "StatementEntityJson");
        if (!_infoStatementEntityJson.equals(_existingStatementEntityJson)) {
          return new RoomOpenHelper.ValidationResult(false, "StatementEntityJson(com.ustadmobile.lib.db.entities.xapi.StatementEntityJson).\n"
                  + " Expected:\n" + _infoStatementEntityJson + "\n"
                  + " Found:\n" + _existingStatementEntityJson);
        }
        final HashMap<String, TableInfo.Column> _columnsPersonPasskey = new HashMap<String, TableInfo.Column>(10);
        _columnsPersonPasskey.put("personPasskeyUid", new TableInfo.Column("personPasskeyUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPasskey.put("ppPersonUid", new TableInfo.Column("ppPersonUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPasskey.put("ppAttestationObj", new TableInfo.Column("ppAttestationObj", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPasskey.put("ppClientDataJson", new TableInfo.Column("ppClientDataJson", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPasskey.put("ppOriginString", new TableInfo.Column("ppOriginString", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPasskey.put("ppId", new TableInfo.Column("ppId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPasskey.put("ppChallengeString", new TableInfo.Column("ppChallengeString", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPasskey.put("ppPublicKey", new TableInfo.Column("ppPublicKey", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPasskey.put("isRevoked", new TableInfo.Column("isRevoked", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPersonPasskey.put("ppPasskeyLct", new TableInfo.Column("ppPasskeyLct", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysPersonPasskey = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesPersonPasskey = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoPersonPasskey = new TableInfo("PersonPasskey", _columnsPersonPasskey, _foreignKeysPersonPasskey, _indicesPersonPasskey);
        final TableInfo _existingPersonPasskey = TableInfo.read(db, "PersonPasskey");
        if (!_infoPersonPasskey.equals(_existingPersonPasskey)) {
          return new RoomOpenHelper.ValidationResult(false, "PersonPasskey(com.ustadmobile.lib.db.entities.PersonPasskey).\n"
                  + " Expected:\n" + _infoPersonPasskey + "\n"
                  + " Found:\n" + _existingPersonPasskey);
        }
        final HashMap<String, TableInfo.Column> _columnsStateEntity = new HashMap<String, TableInfo.Column>(14);
        _columnsStateEntity.put("seActorUid", new TableInfo.Column("seActorUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateEntity.put("seHash", new TableInfo.Column("seHash", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateEntity.put("seActivityUid", new TableInfo.Column("seActivityUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateEntity.put("seStateId", new TableInfo.Column("seStateId", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateEntity.put("seLastMod", new TableInfo.Column("seLastMod", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateEntity.put("seTimeStored", new TableInfo.Column("seTimeStored", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateEntity.put("seContentType", new TableInfo.Column("seContentType", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateEntity.put("seCompressed", new TableInfo.Column("seCompressed", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateEntity.put("seContent", new TableInfo.Column("seContent", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateEntity.put("seDeleted", new TableInfo.Column("seDeleted", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateEntity.put("seRegistrationHi", new TableInfo.Column("seRegistrationHi", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateEntity.put("seRegistrationLo", new TableInfo.Column("seRegistrationLo", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateEntity.put("seH5PPreloaded", new TableInfo.Column("seH5PPreloaded", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateEntity.put("seH5PSubContentId", new TableInfo.Column("seH5PSubContentId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysStateEntity = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesStateEntity = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoStateEntity = new TableInfo("StateEntity", _columnsStateEntity, _foreignKeysStateEntity, _indicesStateEntity);
        final TableInfo _existingStateEntity = TableInfo.read(db, "StateEntity");
        if (!_infoStateEntity.equals(_existingStateEntity)) {
          return new RoomOpenHelper.ValidationResult(false, "StateEntity(com.ustadmobile.lib.db.entities.xapi.StateEntity).\n"
                  + " Expected:\n" + _infoStateEntity + "\n"
                  + " Found:\n" + _existingStateEntity);
        }
        final HashMap<String, TableInfo.Column> _columnsStateDeleteCommand = new HashMap<String, TableInfo.Column>(7);
        _columnsStateDeleteCommand.put("sdcActorUid", new TableInfo.Column("sdcActorUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateDeleteCommand.put("sdcHash", new TableInfo.Column("sdcHash", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateDeleteCommand.put("sdcActivityUid", new TableInfo.Column("sdcActivityUid", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateDeleteCommand.put("sdcStateId", new TableInfo.Column("sdcStateId", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateDeleteCommand.put("sdcLastMod", new TableInfo.Column("sdcLastMod", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateDeleteCommand.put("sdcRegistrationHi", new TableInfo.Column("sdcRegistrationHi", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsStateDeleteCommand.put("sdcRegistrationLo", new TableInfo.Column("sdcRegistrationLo", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysStateDeleteCommand = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesStateDeleteCommand = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoStateDeleteCommand = new TableInfo("StateDeleteCommand", _columnsStateDeleteCommand, _foreignKeysStateDeleteCommand, _indicesStateDeleteCommand);
        final TableInfo _existingStateDeleteCommand = TableInfo.read(db, "StateDeleteCommand");
        if (!_infoStateDeleteCommand.equals(_existingStateDeleteCommand)) {
          return new RoomOpenHelper.ValidationResult(false, "StateDeleteCommand(com.ustadmobile.lib.db.entities.xapi.StateDeleteCommand).\n"
                  + " Expected:\n" + _infoStateDeleteCommand + "\n"
                  + " Found:\n" + _existingStateDeleteCommand);
        }
        final HashMap<String, TableInfo.Column> _columnsOutgoingReplication = new HashMap<String, TableInfo.Column>(7);
        _columnsOutgoingReplication.put("orUid", new TableInfo.Column("orUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOutgoingReplication.put("destNodeId", new TableInfo.Column("destNodeId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOutgoingReplication.put("orTableId", new TableInfo.Column("orTableId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOutgoingReplication.put("orPk1", new TableInfo.Column("orPk1", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsOutgoingReplication.put("orPk2", new TableInfo.Column("orPk2", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsOutgoingReplication.put("orPk3", new TableInfo.Column("orPk3", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        _columnsOutgoingReplication.put("orPk4", new TableInfo.Column("orPk4", "INTEGER", true, 0, "0", TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysOutgoingReplication = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesOutgoingReplication = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoOutgoingReplication = new TableInfo("OutgoingReplication", _columnsOutgoingReplication, _foreignKeysOutgoingReplication, _indicesOutgoingReplication);
        final TableInfo _existingOutgoingReplication = TableInfo.read(db, "OutgoingReplication");
        if (!_infoOutgoingReplication.equals(_existingOutgoingReplication)) {
          return new RoomOpenHelper.ValidationResult(false, "OutgoingReplication(com.ustadmobile.door.entities.OutgoingReplication).\n"
                  + " Expected:\n" + _infoOutgoingReplication + "\n"
                  + " Found:\n" + _existingOutgoingReplication);
        }
        final HashMap<String, TableInfo.Column> _columnsReplicationOperation = new HashMap<String, TableInfo.Column>(3);
        _columnsReplicationOperation.put("repOpRemoteNodeId", new TableInfo.Column("repOpRemoteNodeId", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReplicationOperation.put("repOpTableId", new TableInfo.Column("repOpTableId", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsReplicationOperation.put("repOpStatus", new TableInfo.Column("repOpStatus", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysReplicationOperation = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesReplicationOperation = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoReplicationOperation = new TableInfo("ReplicationOperation", _columnsReplicationOperation, _foreignKeysReplicationOperation, _indicesReplicationOperation);
        final TableInfo _existingReplicationOperation = TableInfo.read(db, "ReplicationOperation");
        if (!_infoReplicationOperation.equals(_existingReplicationOperation)) {
          return new RoomOpenHelper.ValidationResult(false, "ReplicationOperation(com.ustadmobile.door.entities.ReplicationOperation).\n"
                  + " Expected:\n" + _infoReplicationOperation + "\n"
                  + " Found:\n" + _existingReplicationOperation);
        }
        final HashMap<String, TableInfo.Column> _columnsPendingRepositorySession = new HashMap<String, TableInfo.Column>(3);
        _columnsPendingRepositorySession.put("rsUid", new TableInfo.Column("rsUid", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPendingRepositorySession.put("remoteNodeId", new TableInfo.Column("remoteNodeId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsPendingRepositorySession.put("endpointUrl", new TableInfo.Column("endpointUrl", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysPendingRepositorySession = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesPendingRepositorySession = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoPendingRepositorySession = new TableInfo("PendingRepositorySession", _columnsPendingRepositorySession, _foreignKeysPendingRepositorySession, _indicesPendingRepositorySession);
        final TableInfo _existingPendingRepositorySession = TableInfo.read(db, "PendingRepositorySession");
        if (!_infoPendingRepositorySession.equals(_existingPendingRepositorySession)) {
          return new RoomOpenHelper.ValidationResult(false, "PendingRepositorySession(com.ustadmobile.door.entities.PendingRepositorySession).\n"
                  + " Expected:\n" + _infoPendingRepositorySession + "\n"
                  + " Found:\n" + _existingPendingRepositorySession);
        }
        final HashMap<String, TableInfo.Column> _columnsDoorNode = new HashMap<String, TableInfo.Column>(3);
        _columnsDoorNode.put("nodeId", new TableInfo.Column("nodeId", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDoorNode.put("auth", new TableInfo.Column("auth", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
        _columnsDoorNode.put("rel", new TableInfo.Column("rel", "INTEGER", true, 0, "2", TableInfo.CREATED_FROM_ENTITY));
        final HashSet<TableInfo.ForeignKey> _foreignKeysDoorNode = new HashSet<TableInfo.ForeignKey>(0);
        final HashSet<TableInfo.Index> _indicesDoorNode = new HashSet<TableInfo.Index>(0);
        final TableInfo _infoDoorNode = new TableInfo("DoorNode", _columnsDoorNode, _foreignKeysDoorNode, _indicesDoorNode);
        final TableInfo _existingDoorNode = TableInfo.read(db, "DoorNode");
        if (!_infoDoorNode.equals(_existingDoorNode)) {
          return new RoomOpenHelper.ValidationResult(false, "DoorNode(com.ustadmobile.door.entities.DoorNode).\n"
                  + " Expected:\n" + _infoDoorNode + "\n"
                  + " Found:\n" + _existingDoorNode);
        }
        return new RoomOpenHelper.ValidationResult(true, null);
      }
    }, "9bec28e0e31ae15d6a349b56de026a6f", "c1d954baf521dafdc7efcff891611257");
    final SupportSQLiteOpenHelper.Configuration _sqliteConfig = SupportSQLiteOpenHelper.Configuration.builder(config.context).name(config.name).callback(_openCallback).build();
    final SupportSQLiteOpenHelper _helper = config.sqliteOpenHelperFactory.create(_sqliteConfig);
    return _helper;
  }

  @Override
  @NonNull
  protected InvalidationTracker createInvalidationTracker() {
    final HashMap<String, String> _shadowTablesMap = new HashMap<String, String>(0);
    final HashMap<String, Set<String>> _viewTables = new HashMap<String, Set<String>>(0);
    return new InvalidationTracker(this, _shadowTablesMap, _viewTables, "ClazzLog","ClazzLogAttendanceRecord","Schedule","HolidayCalendar","Holiday","Person","Clazz","ClazzEnrolment","LeavingReason","ClazzInvite","ContentEntry","ContentEntryContentCategoryJoin","ContentEntryParentChildJoin","ContentEntryRelatedEntryJoin","ContentCategorySchema","ContentCategory","Language","LanguageVariant","PersonAuth","PersonGroup","PersonGroupMember","PersonPicture","VerbEntity","ActivityEntity","StatementEntity","ActorEntity","SyncNode","Comments","Report","Site","SiteTerms","PersonParentJoin","ScopedGrant","ErrorReport","ClazzAssignment","CourseAssignmentSubmission","CourseAssignmentSubmissionFile","CourseAssignmentMark","PeerReviewerAllocation","PersonAuth2","UserSession","ContentJob","ContentEntryImportJob","CourseBlock","CourseTerminology","CourseGroupSet","CourseGroupMember","ContentEntryPicture","ActivityInteractionEntity","CoursePicture","DiscussionPost","ExternalAppPermission","Message","StudentResult","ContentEntryVersion","TransferJob","TransferJobItem","CacheLockJoin","OfflineItem","OfflineItemPendingTransferJob","DeletedItem","EnrolmentRequest","CoursePermission","SystemPermission","CourseBlockPicture","ContentEntryPicture2","TransferJobError","VerbLangMapEntry","GroupMemberActorJoin","ActivityLangMapEntry","ActivityExtensionEntity","StatementContextActivityJoin","XapiSessionEntity","StatementEntityJson","PersonPasskey","StateEntity","StateDeleteCommand","OutgoingReplication","ReplicationOperation","PendingRepositorySession","DoorNode");
  }

  @Override
  public void clearAllTables() {
    super.assertNotMainThread();
    final SupportSQLiteDatabase _db = super.getOpenHelper().getWritableDatabase();
    try {
      super.beginTransaction();
      _db.execSQL("DELETE FROM `ClazzLog`");
      _db.execSQL("DELETE FROM `ClazzLogAttendanceRecord`");
      _db.execSQL("DELETE FROM `Schedule`");
      _db.execSQL("DELETE FROM `HolidayCalendar`");
      _db.execSQL("DELETE FROM `Holiday`");
      _db.execSQL("DELETE FROM `Person`");
      _db.execSQL("DELETE FROM `Clazz`");
      _db.execSQL("DELETE FROM `ClazzEnrolment`");
      _db.execSQL("DELETE FROM `LeavingReason`");
      _db.execSQL("DELETE FROM `ClazzInvite`");
      _db.execSQL("DELETE FROM `ContentEntry`");
      _db.execSQL("DELETE FROM `ContentEntryContentCategoryJoin`");
      _db.execSQL("DELETE FROM `ContentEntryParentChildJoin`");
      _db.execSQL("DELETE FROM `ContentEntryRelatedEntryJoin`");
      _db.execSQL("DELETE FROM `ContentCategorySchema`");
      _db.execSQL("DELETE FROM `ContentCategory`");
      _db.execSQL("DELETE FROM `Language`");
      _db.execSQL("DELETE FROM `LanguageVariant`");
      _db.execSQL("DELETE FROM `PersonAuth`");
      _db.execSQL("DELETE FROM `PersonGroup`");
      _db.execSQL("DELETE FROM `PersonGroupMember`");
      _db.execSQL("DELETE FROM `PersonPicture`");
      _db.execSQL("DELETE FROM `VerbEntity`");
      _db.execSQL("DELETE FROM `ActivityEntity`");
      _db.execSQL("DELETE FROM `StatementEntity`");
      _db.execSQL("DELETE FROM `ActorEntity`");
      _db.execSQL("DELETE FROM `SyncNode`");
      _db.execSQL("DELETE FROM `Comments`");
      _db.execSQL("DELETE FROM `Report`");
      _db.execSQL("DELETE FROM `Site`");
      _db.execSQL("DELETE FROM `SiteTerms`");
      _db.execSQL("DELETE FROM `PersonParentJoin`");
      _db.execSQL("DELETE FROM `ScopedGrant`");
      _db.execSQL("DELETE FROM `ErrorReport`");
      _db.execSQL("DELETE FROM `ClazzAssignment`");
      _db.execSQL("DELETE FROM `CourseAssignmentSubmission`");
      _db.execSQL("DELETE FROM `CourseAssignmentSubmissionFile`");
      _db.execSQL("DELETE FROM `CourseAssignmentMark`");
      _db.execSQL("DELETE FROM `PeerReviewerAllocation`");
      _db.execSQL("DELETE FROM `PersonAuth2`");
      _db.execSQL("DELETE FROM `UserSession`");
      _db.execSQL("DELETE FROM `ContentJob`");
      _db.execSQL("DELETE FROM `ContentEntryImportJob`");
      _db.execSQL("DELETE FROM `CourseBlock`");
      _db.execSQL("DELETE FROM `CourseTerminology`");
      _db.execSQL("DELETE FROM `CourseGroupSet`");
      _db.execSQL("DELETE FROM `CourseGroupMember`");
      _db.execSQL("DELETE FROM `ContentEntryPicture`");
      _db.execSQL("DELETE FROM `ActivityInteractionEntity`");
      _db.execSQL("DELETE FROM `CoursePicture`");
      _db.execSQL("DELETE FROM `DiscussionPost`");
      _db.execSQL("DELETE FROM `ExternalAppPermission`");
      _db.execSQL("DELETE FROM `Message`");
      _db.execSQL("DELETE FROM `StudentResult`");
      _db.execSQL("DELETE FROM `ContentEntryVersion`");
      _db.execSQL("DELETE FROM `TransferJob`");
      _db.execSQL("DELETE FROM `TransferJobItem`");
      _db.execSQL("DELETE FROM `CacheLockJoin`");
      _db.execSQL("DELETE FROM `OfflineItem`");
      _db.execSQL("DELETE FROM `OfflineItemPendingTransferJob`");
      _db.execSQL("DELETE FROM `DeletedItem`");
      _db.execSQL("DELETE FROM `EnrolmentRequest`");
      _db.execSQL("DELETE FROM `CoursePermission`");
      _db.execSQL("DELETE FROM `SystemPermission`");
      _db.execSQL("DELETE FROM `CourseBlockPicture`");
      _db.execSQL("DELETE FROM `ContentEntryPicture2`");
      _db.execSQL("DELETE FROM `TransferJobError`");
      _db.execSQL("DELETE FROM `VerbLangMapEntry`");
      _db.execSQL("DELETE FROM `GroupMemberActorJoin`");
      _db.execSQL("DELETE FROM `ActivityLangMapEntry`");
      _db.execSQL("DELETE FROM `ActivityExtensionEntity`");
      _db.execSQL("DELETE FROM `StatementContextActivityJoin`");
      _db.execSQL("DELETE FROM `XapiSessionEntity`");
      _db.execSQL("DELETE FROM `StatementEntityJson`");
      _db.execSQL("DELETE FROM `PersonPasskey`");
      _db.execSQL("DELETE FROM `StateEntity`");
      _db.execSQL("DELETE FROM `StateDeleteCommand`");
      _db.execSQL("DELETE FROM `OutgoingReplication`");
      _db.execSQL("DELETE FROM `ReplicationOperation`");
      _db.execSQL("DELETE FROM `PendingRepositorySession`");
      _db.execSQL("DELETE FROM `DoorNode`");
      super.setTransactionSuccessful();
    } finally {
      super.endTransaction();
      _db.query("PRAGMA wal_checkpoint(FULL)").close();
      if (!_db.inTransaction()) {
        _db.execSQL("VACUUM");
      }
    }
  }

  @Override
  @NonNull
  protected Map<Class<?>, List<Class<?>>> getRequiredTypeConverters() {
    final HashMap<Class<?>, List<Class<?>>> _typeConvertersMap = new HashMap<Class<?>, List<Class<?>>>();
    _typeConvertersMap.put(PersonDao.class, PersonDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ClazzDao.class, ClazzDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(CourseBlockDao.class, CourseBlockDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(CourseTerminologyDao.class, CourseTerminologyDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(CourseGroupSetDao.class, CourseGroupSetDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(CourseGroupMemberDao.class, CourseGroupMemberDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ClazzEnrolmentDao.class, ClazzEnrolmentDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(LeavingReasonDao.class, LeavingReasonDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ContentEntryDao.class, ContentEntryDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ContentEntryContentCategoryJoinDao.class, ContentEntryContentCategoryJoinDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ContentEntryParentChildJoinDao.class, ContentEntryParentChildJoinDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ContentEntryRelatedEntryJoinDao.class, ContentEntryRelatedEntryJoinDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ContentCategorySchemaDao.class, ContentCategorySchemaDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ContentCategoryDao.class, ContentCategoryDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(LanguageDao.class, LanguageDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(LanguageVariantDao.class, LanguageVariantDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(PersonAuthDao.class, PersonAuthDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(PersonGroupDao.class, PersonGroupDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(PersonGroupMemberDao.class, PersonGroupMemberDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(PersonPictureDao.class, PersonPictureDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(VerbDao.class, VerbDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ActivityEntityDao.class, ActivityEntityDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ReportDao.class, ReportDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(StatementDao.class, StatementDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ActorDao.class, ActorDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ClazzLogAttendanceRecordDao.class, ClazzLogAttendanceRecordDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ClazzLogDao.class, ClazzLogDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ScheduleDao.class, ScheduleDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(HolidayCalendarDao.class, HolidayCalendarDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(HolidayDao.class, HolidayDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ClazzAssignmentDao.class, ClazzAssignmentDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(CourseAssignmentSubmissionDao.class, CourseAssignmentSubmissionDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(CourseAssignmentSubmissionFileDao.class, CourseAssignmentSubmissionFileDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(CourseAssignmentMarkDao.class, CourseAssignmentMarkDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(CommentsDao.class, CommentsDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(SyncNodeDao.class, SyncNodeDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(SiteDao.class, SiteDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(SiteTermsDao.class, SiteTermsDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(PersonParentJoinDao.class, PersonParentJoinDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ScopedGrantDao.class, ScopedGrantDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ErrorReportDao.class, ErrorReportDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(PersonAuth2Dao.class, PersonAuth2Dao_Impl.getRequiredConverters());
    _typeConvertersMap.put(UserSessionDao.class, UserSessionDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ContentEntryImportJobDao.class, ContentEntryImportJobDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(CoursePictureDao.class, CoursePictureDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ContentEntryPictureDao.class, ContentEntryPictureDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(MessageDao.class, MessageDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(PeerReviewerAllocationDao.class, PeerReviewerAllocationDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(DiscussionPostDao.class, DiscussionPostDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ExternalAppPermissionDao.class, ExternalAppPermissionDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ContentEntryVersionDao.class, ContentEntryVersionDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(OutgoingReplicationDao.class, OutgoingReplicationDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(TransferJobDao.class, TransferJobDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(TransferJobItemDao.class, TransferJobItemDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(CacheLockJoinDao.class, CacheLockJoinDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(OfflineItemDao.class, OfflineItemDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(DeletedItemDao.class, DeletedItemDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(EnrolmentRequestDao.class, EnrolmentRequestDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(CoursePermissionDao.class, CoursePermissionDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(SystemPermissionDao.class, SystemPermissionDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(CourseBlockPictureDao.class, CourseBlockPictureDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ContentEntryPicture2Dao.class, ContentEntryPicture2Dao_Impl.getRequiredConverters());
    _typeConvertersMap.put(TransferJobErrorDao.class, TransferJobErrorDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(StudentResultDao.class, StudentResultDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(VerbLangMapEntryDao.class, VerbLangMapEntryDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(GroupMemberActorJoinDao.class, GroupMemberActorJoinDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ActivityLangMapEntryDao.class, ActivityLangMapEntryDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ActivityInteractionDao.class, ActivityInteractionDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ActivityExtensionDao.class, ActivityExtensionDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(StatementContextActivityJoinDao.class, StatementContextActivityJoinDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(XapiSessionEntityDao.class, XapiSessionEntityDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(StatementEntityJsonDao.class, StatementEntityJsonDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(PersonPasskeyDao.class, PersonPasskeyDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(StateEntityDao.class, StateEntityDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(StateDeleteCommandDao.class, StateDeleteCommandDao_Impl.getRequiredConverters());
    _typeConvertersMap.put(ClazzInviteDao.class, ClazzInviteDao_Impl.getRequiredConverters());
    return _typeConvertersMap;
  }

  @Override
  @NonNull
  public Set<Class<? extends AutoMigrationSpec>> getRequiredAutoMigrationSpecs() {
    final HashSet<Class<? extends AutoMigrationSpec>> _autoMigrationSpecsSet = new HashSet<Class<? extends AutoMigrationSpec>>();
    return _autoMigrationSpecsSet;
  }

  @Override
  @NonNull
  public List<Migration> getAutoMigrations(
      @NonNull final Map<Class<? extends AutoMigrationSpec>, AutoMigrationSpec> autoMigrationSpecs) {
    final List<Migration> _autoMigrations = new ArrayList<Migration>();
    return _autoMigrations;
  }

  @Override
  public PersonDao personDao() {
    if (_personDao != null) {
      return _personDao;
    } else {
      synchronized(this) {
        if(_personDao == null) {
          _personDao = new PersonDao_Impl(this);
        }
        return _personDao;
      }
    }
  }

  @Override
  public ClazzDao clazzDao() {
    if (_clazzDao != null) {
      return _clazzDao;
    } else {
      synchronized(this) {
        if(_clazzDao == null) {
          _clazzDao = new ClazzDao_Impl(this);
        }
        return _clazzDao;
      }
    }
  }

  @Override
  public CourseBlockDao courseBlockDao() {
    if (_courseBlockDao != null) {
      return _courseBlockDao;
    } else {
      synchronized(this) {
        if(_courseBlockDao == null) {
          _courseBlockDao = new CourseBlockDao_Impl(this);
        }
        return _courseBlockDao;
      }
    }
  }

  @Override
  public CourseTerminologyDao courseTerminologyDao() {
    if (_courseTerminologyDao != null) {
      return _courseTerminologyDao;
    } else {
      synchronized(this) {
        if(_courseTerminologyDao == null) {
          _courseTerminologyDao = new CourseTerminologyDao_Impl(this);
        }
        return _courseTerminologyDao;
      }
    }
  }

  @Override
  public CourseGroupSetDao courseGroupSetDao() {
    if (_courseGroupSetDao != null) {
      return _courseGroupSetDao;
    } else {
      synchronized(this) {
        if(_courseGroupSetDao == null) {
          _courseGroupSetDao = new CourseGroupSetDao_Impl(this);
        }
        return _courseGroupSetDao;
      }
    }
  }

  @Override
  public CourseGroupMemberDao courseGroupMemberDao() {
    if (_courseGroupMemberDao != null) {
      return _courseGroupMemberDao;
    } else {
      synchronized(this) {
        if(_courseGroupMemberDao == null) {
          _courseGroupMemberDao = new CourseGroupMemberDao_Impl(this);
        }
        return _courseGroupMemberDao;
      }
    }
  }

  @Override
  public ClazzEnrolmentDao clazzEnrolmentDao() {
    if (_clazzEnrolmentDao != null) {
      return _clazzEnrolmentDao;
    } else {
      synchronized(this) {
        if(_clazzEnrolmentDao == null) {
          _clazzEnrolmentDao = new ClazzEnrolmentDao_Impl(this);
        }
        return _clazzEnrolmentDao;
      }
    }
  }

  @Override
  public LeavingReasonDao leavingReasonDao() {
    if (_leavingReasonDao != null) {
      return _leavingReasonDao;
    } else {
      synchronized(this) {
        if(_leavingReasonDao == null) {
          _leavingReasonDao = new LeavingReasonDao_Impl(this);
        }
        return _leavingReasonDao;
      }
    }
  }

  @Override
  public ContentEntryDao contentEntryDao() {
    if (_contentEntryDao != null) {
      return _contentEntryDao;
    } else {
      synchronized(this) {
        if(_contentEntryDao == null) {
          _contentEntryDao = new ContentEntryDao_Impl(this);
        }
        return _contentEntryDao;
      }
    }
  }

  @Override
  public ContentEntryContentCategoryJoinDao contentEntryContentCategoryJoinDao() {
    if (_contentEntryContentCategoryJoinDao != null) {
      return _contentEntryContentCategoryJoinDao;
    } else {
      synchronized(this) {
        if(_contentEntryContentCategoryJoinDao == null) {
          _contentEntryContentCategoryJoinDao = new ContentEntryContentCategoryJoinDao_Impl(this);
        }
        return _contentEntryContentCategoryJoinDao;
      }
    }
  }

  @Override
  public ContentEntryParentChildJoinDao contentEntryParentChildJoinDao() {
    if (_contentEntryParentChildJoinDao != null) {
      return _contentEntryParentChildJoinDao;
    } else {
      synchronized(this) {
        if(_contentEntryParentChildJoinDao == null) {
          _contentEntryParentChildJoinDao = new ContentEntryParentChildJoinDao_Impl(this);
        }
        return _contentEntryParentChildJoinDao;
      }
    }
  }

  @Override
  public ContentEntryRelatedEntryJoinDao contentEntryRelatedEntryJoinDao() {
    if (_contentEntryRelatedEntryJoinDao != null) {
      return _contentEntryRelatedEntryJoinDao;
    } else {
      synchronized(this) {
        if(_contentEntryRelatedEntryJoinDao == null) {
          _contentEntryRelatedEntryJoinDao = new ContentEntryRelatedEntryJoinDao_Impl(this);
        }
        return _contentEntryRelatedEntryJoinDao;
      }
    }
  }

  @Override
  public ContentCategorySchemaDao contentCategorySchemaDao() {
    if (_contentCategorySchemaDao != null) {
      return _contentCategorySchemaDao;
    } else {
      synchronized(this) {
        if(_contentCategorySchemaDao == null) {
          _contentCategorySchemaDao = new ContentCategorySchemaDao_Impl(this);
        }
        return _contentCategorySchemaDao;
      }
    }
  }

  @Override
  public ContentCategoryDao contentCategoryDao() {
    if (_contentCategoryDao != null) {
      return _contentCategoryDao;
    } else {
      synchronized(this) {
        if(_contentCategoryDao == null) {
          _contentCategoryDao = new ContentCategoryDao_Impl(this);
        }
        return _contentCategoryDao;
      }
    }
  }

  @Override
  public LanguageDao languageDao() {
    if (_languageDao != null) {
      return _languageDao;
    } else {
      synchronized(this) {
        if(_languageDao == null) {
          _languageDao = new LanguageDao_Impl(this);
        }
        return _languageDao;
      }
    }
  }

  @Override
  public LanguageVariantDao languageVariantDao() {
    if (_languageVariantDao != null) {
      return _languageVariantDao;
    } else {
      synchronized(this) {
        if(_languageVariantDao == null) {
          _languageVariantDao = new LanguageVariantDao_Impl(this);
        }
        return _languageVariantDao;
      }
    }
  }

  @Override
  public PersonAuthDao personAuthDao() {
    if (_personAuthDao != null) {
      return _personAuthDao;
    } else {
      synchronized(this) {
        if(_personAuthDao == null) {
          _personAuthDao = new PersonAuthDao_Impl(this);
        }
        return _personAuthDao;
      }
    }
  }

  @Override
  public PersonGroupDao personGroupDao() {
    if (_personGroupDao != null) {
      return _personGroupDao;
    } else {
      synchronized(this) {
        if(_personGroupDao == null) {
          _personGroupDao = new PersonGroupDao_Impl(this);
        }
        return _personGroupDao;
      }
    }
  }

  @Override
  public PersonGroupMemberDao personGroupMemberDao() {
    if (_personGroupMemberDao != null) {
      return _personGroupMemberDao;
    } else {
      synchronized(this) {
        if(_personGroupMemberDao == null) {
          _personGroupMemberDao = new PersonGroupMemberDao_Impl(this);
        }
        return _personGroupMemberDao;
      }
    }
  }

  @Override
  public PersonPictureDao personPictureDao() {
    if (_personPictureDao != null) {
      return _personPictureDao;
    } else {
      synchronized(this) {
        if(_personPictureDao == null) {
          _personPictureDao = new PersonPictureDao_Impl(this);
        }
        return _personPictureDao;
      }
    }
  }

  @Override
  public VerbDao verbDao() {
    if (_verbDao != null) {
      return _verbDao;
    } else {
      synchronized(this) {
        if(_verbDao == null) {
          _verbDao = new VerbDao_Impl(this);
        }
        return _verbDao;
      }
    }
  }

  @Override
  public ActivityEntityDao activityEntityDao() {
    if (_activityEntityDao != null) {
      return _activityEntityDao;
    } else {
      synchronized(this) {
        if(_activityEntityDao == null) {
          _activityEntityDao = new ActivityEntityDao_Impl(this);
        }
        return _activityEntityDao;
      }
    }
  }

  @Override
  public ReportDao reportDao() {
    if (_reportDao != null) {
      return _reportDao;
    } else {
      synchronized(this) {
        if(_reportDao == null) {
          _reportDao = new ReportDao_Impl(this);
        }
        return _reportDao;
      }
    }
  }

  @Override
  public StatementDao statementDao() {
    if (_statementDao != null) {
      return _statementDao;
    } else {
      synchronized(this) {
        if(_statementDao == null) {
          _statementDao = new StatementDao_Impl(this);
        }
        return _statementDao;
      }
    }
  }

  @Override
  public ActorDao actorDao() {
    if (_actorDao != null) {
      return _actorDao;
    } else {
      synchronized(this) {
        if(_actorDao == null) {
          _actorDao = new ActorDao_Impl(this);
        }
        return _actorDao;
      }
    }
  }

  @Override
  public ClazzLogAttendanceRecordDao clazzLogAttendanceRecordDao() {
    if (_clazzLogAttendanceRecordDao != null) {
      return _clazzLogAttendanceRecordDao;
    } else {
      synchronized(this) {
        if(_clazzLogAttendanceRecordDao == null) {
          _clazzLogAttendanceRecordDao = new ClazzLogAttendanceRecordDao_Impl(this);
        }
        return _clazzLogAttendanceRecordDao;
      }
    }
  }

  @Override
  public ClazzLogDao clazzLogDao() {
    if (_clazzLogDao != null) {
      return _clazzLogDao;
    } else {
      synchronized(this) {
        if(_clazzLogDao == null) {
          _clazzLogDao = new ClazzLogDao_Impl(this);
        }
        return _clazzLogDao;
      }
    }
  }

  @Override
  public ScheduleDao scheduleDao() {
    if (_scheduleDao != null) {
      return _scheduleDao;
    } else {
      synchronized(this) {
        if(_scheduleDao == null) {
          _scheduleDao = new ScheduleDao_Impl(this);
        }
        return _scheduleDao;
      }
    }
  }

  @Override
  public HolidayCalendarDao holidayCalendarDao() {
    if (_holidayCalendarDao != null) {
      return _holidayCalendarDao;
    } else {
      synchronized(this) {
        if(_holidayCalendarDao == null) {
          _holidayCalendarDao = new HolidayCalendarDao_Impl(this);
        }
        return _holidayCalendarDao;
      }
    }
  }

  @Override
  public HolidayDao holidayDao() {
    if (_holidayDao != null) {
      return _holidayDao;
    } else {
      synchronized(this) {
        if(_holidayDao == null) {
          _holidayDao = new HolidayDao_Impl(this);
        }
        return _holidayDao;
      }
    }
  }

  @Override
  public ClazzAssignmentDao clazzAssignmentDao() {
    if (_clazzAssignmentDao != null) {
      return _clazzAssignmentDao;
    } else {
      synchronized(this) {
        if(_clazzAssignmentDao == null) {
          _clazzAssignmentDao = new ClazzAssignmentDao_Impl(this);
        }
        return _clazzAssignmentDao;
      }
    }
  }

  @Override
  public CourseAssignmentSubmissionDao courseAssignmentSubmissionDao() {
    if (_courseAssignmentSubmissionDao != null) {
      return _courseAssignmentSubmissionDao;
    } else {
      synchronized(this) {
        if(_courseAssignmentSubmissionDao == null) {
          _courseAssignmentSubmissionDao = new CourseAssignmentSubmissionDao_Impl(this);
        }
        return _courseAssignmentSubmissionDao;
      }
    }
  }

  @Override
  public CourseAssignmentSubmissionFileDao courseAssignmentSubmissionFileDao() {
    if (_courseAssignmentSubmissionFileDao != null) {
      return _courseAssignmentSubmissionFileDao;
    } else {
      synchronized(this) {
        if(_courseAssignmentSubmissionFileDao == null) {
          _courseAssignmentSubmissionFileDao = new CourseAssignmentSubmissionFileDao_Impl(this);
        }
        return _courseAssignmentSubmissionFileDao;
      }
    }
  }

  @Override
  public CourseAssignmentMarkDao courseAssignmentMarkDao() {
    if (_courseAssignmentMarkDao != null) {
      return _courseAssignmentMarkDao;
    } else {
      synchronized(this) {
        if(_courseAssignmentMarkDao == null) {
          _courseAssignmentMarkDao = new CourseAssignmentMarkDao_Impl(this);
        }
        return _courseAssignmentMarkDao;
      }
    }
  }

  @Override
  public CommentsDao commentsDao() {
    if (_commentsDao != null) {
      return _commentsDao;
    } else {
      synchronized(this) {
        if(_commentsDao == null) {
          _commentsDao = new CommentsDao_Impl(this);
        }
        return _commentsDao;
      }
    }
  }

  @Override
  public SyncNodeDao syncNodeDao() {
    if (_syncNodeDao != null) {
      return _syncNodeDao;
    } else {
      synchronized(this) {
        if(_syncNodeDao == null) {
          _syncNodeDao = new SyncNodeDao_Impl(this);
        }
        return _syncNodeDao;
      }
    }
  }

  @Override
  public SiteDao siteDao() {
    if (_siteDao != null) {
      return _siteDao;
    } else {
      synchronized(this) {
        if(_siteDao == null) {
          _siteDao = new SiteDao_Impl(this);
        }
        return _siteDao;
      }
    }
  }

  @Override
  public SiteTermsDao siteTermsDao() {
    if (_siteTermsDao != null) {
      return _siteTermsDao;
    } else {
      synchronized(this) {
        if(_siteTermsDao == null) {
          _siteTermsDao = new SiteTermsDao_Impl(this);
        }
        return _siteTermsDao;
      }
    }
  }

  @Override
  public PersonParentJoinDao personParentJoinDao() {
    if (_personParentJoinDao != null) {
      return _personParentJoinDao;
    } else {
      synchronized(this) {
        if(_personParentJoinDao == null) {
          _personParentJoinDao = new PersonParentJoinDao_Impl(this);
        }
        return _personParentJoinDao;
      }
    }
  }

  @Override
  public ScopedGrantDao scopedGrantDao() {
    if (_scopedGrantDao != null) {
      return _scopedGrantDao;
    } else {
      synchronized(this) {
        if(_scopedGrantDao == null) {
          _scopedGrantDao = new ScopedGrantDao_Impl(this);
        }
        return _scopedGrantDao;
      }
    }
  }

  @Override
  public ErrorReportDao errorReportDao() {
    if (_errorReportDao != null) {
      return _errorReportDao;
    } else {
      synchronized(this) {
        if(_errorReportDao == null) {
          _errorReportDao = new ErrorReportDao_Impl(this);
        }
        return _errorReportDao;
      }
    }
  }

  @Override
  public PersonAuth2Dao personAuth2Dao() {
    if (_personAuth2Dao != null) {
      return _personAuth2Dao;
    } else {
      synchronized(this) {
        if(_personAuth2Dao == null) {
          _personAuth2Dao = new PersonAuth2Dao_Impl(this);
        }
        return _personAuth2Dao;
      }
    }
  }

  @Override
  public UserSessionDao userSessionDao() {
    if (_userSessionDao != null) {
      return _userSessionDao;
    } else {
      synchronized(this) {
        if(_userSessionDao == null) {
          _userSessionDao = new UserSessionDao_Impl(this);
        }
        return _userSessionDao;
      }
    }
  }

  @Override
  public ContentEntryImportJobDao contentEntryImportJobDao() {
    if (_contentEntryImportJobDao != null) {
      return _contentEntryImportJobDao;
    } else {
      synchronized(this) {
        if(_contentEntryImportJobDao == null) {
          _contentEntryImportJobDao = new ContentEntryImportJobDao_Impl(this);
        }
        return _contentEntryImportJobDao;
      }
    }
  }

  @Override
  public CoursePictureDao coursePictureDao() {
    if (_coursePictureDao != null) {
      return _coursePictureDao;
    } else {
      synchronized(this) {
        if(_coursePictureDao == null) {
          _coursePictureDao = new CoursePictureDao_Impl(this);
        }
        return _coursePictureDao;
      }
    }
  }

  @Override
  public ContentEntryPictureDao contentEntryPictureDao() {
    if (_contentEntryPictureDao != null) {
      return _contentEntryPictureDao;
    } else {
      synchronized(this) {
        if(_contentEntryPictureDao == null) {
          _contentEntryPictureDao = new ContentEntryPictureDao_Impl(this);
        }
        return _contentEntryPictureDao;
      }
    }
  }

  @Override
  public MessageDao messageDao() {
    if (_messageDao != null) {
      return _messageDao;
    } else {
      synchronized(this) {
        if(_messageDao == null) {
          _messageDao = new MessageDao_Impl(this);
        }
        return _messageDao;
      }
    }
  }

  @Override
  public PeerReviewerAllocationDao peerReviewerAllocationDao() {
    if (_peerReviewerAllocationDao != null) {
      return _peerReviewerAllocationDao;
    } else {
      synchronized(this) {
        if(_peerReviewerAllocationDao == null) {
          _peerReviewerAllocationDao = new PeerReviewerAllocationDao_Impl(this);
        }
        return _peerReviewerAllocationDao;
      }
    }
  }

  @Override
  public DiscussionPostDao discussionPostDao() {
    if (_discussionPostDao != null) {
      return _discussionPostDao;
    } else {
      synchronized(this) {
        if(_discussionPostDao == null) {
          _discussionPostDao = new DiscussionPostDao_Impl(this);
        }
        return _discussionPostDao;
      }
    }
  }

  @Override
  public ExternalAppPermissionDao externalAppPermissionDao() {
    if (_externalAppPermissionDao != null) {
      return _externalAppPermissionDao;
    } else {
      synchronized(this) {
        if(_externalAppPermissionDao == null) {
          _externalAppPermissionDao = new ExternalAppPermissionDao_Impl(this);
        }
        return _externalAppPermissionDao;
      }
    }
  }

  @Override
  public ContentEntryVersionDao contentEntryVersionDao() {
    if (_contentEntryVersionDao != null) {
      return _contentEntryVersionDao;
    } else {
      synchronized(this) {
        if(_contentEntryVersionDao == null) {
          _contentEntryVersionDao = new ContentEntryVersionDao_Impl(this);
        }
        return _contentEntryVersionDao;
      }
    }
  }

  @Override
  public OutgoingReplicationDao outgoingReplicationDao() {
    if (_outgoingReplicationDao != null) {
      return _outgoingReplicationDao;
    } else {
      synchronized(this) {
        if(_outgoingReplicationDao == null) {
          _outgoingReplicationDao = new OutgoingReplicationDao_Impl(this);
        }
        return _outgoingReplicationDao;
      }
    }
  }

  @Override
  public TransferJobDao transferJobDao() {
    if (_transferJobDao != null) {
      return _transferJobDao;
    } else {
      synchronized(this) {
        if(_transferJobDao == null) {
          _transferJobDao = new TransferJobDao_Impl(this);
        }
        return _transferJobDao;
      }
    }
  }

  @Override
  public TransferJobItemDao transferJobItemDao() {
    if (_transferJobItemDao != null) {
      return _transferJobItemDao;
    } else {
      synchronized(this) {
        if(_transferJobItemDao == null) {
          _transferJobItemDao = new TransferJobItemDao_Impl(this);
        }
        return _transferJobItemDao;
      }
    }
  }

  @Override
  public CacheLockJoinDao cacheLockJoinDao() {
    if (_cacheLockJoinDao != null) {
      return _cacheLockJoinDao;
    } else {
      synchronized(this) {
        if(_cacheLockJoinDao == null) {
          _cacheLockJoinDao = new CacheLockJoinDao_Impl(this);
        }
        return _cacheLockJoinDao;
      }
    }
  }

  @Override
  public OfflineItemDao offlineItemDao() {
    if (_offlineItemDao != null) {
      return _offlineItemDao;
    } else {
      synchronized(this) {
        if(_offlineItemDao == null) {
          _offlineItemDao = new OfflineItemDao_Impl(this);
        }
        return _offlineItemDao;
      }
    }
  }

  @Override
  public DeletedItemDao deletedItemDao() {
    if (_deletedItemDao != null) {
      return _deletedItemDao;
    } else {
      synchronized(this) {
        if(_deletedItemDao == null) {
          _deletedItemDao = new DeletedItemDao_Impl(this);
        }
        return _deletedItemDao;
      }
    }
  }

  @Override
  public EnrolmentRequestDao enrolmentRequestDao() {
    if (_enrolmentRequestDao != null) {
      return _enrolmentRequestDao;
    } else {
      synchronized(this) {
        if(_enrolmentRequestDao == null) {
          _enrolmentRequestDao = new EnrolmentRequestDao_Impl(this);
        }
        return _enrolmentRequestDao;
      }
    }
  }

  @Override
  public CoursePermissionDao coursePermissionDao() {
    if (_coursePermissionDao != null) {
      return _coursePermissionDao;
    } else {
      synchronized(this) {
        if(_coursePermissionDao == null) {
          _coursePermissionDao = new CoursePermissionDao_Impl(this);
        }
        return _coursePermissionDao;
      }
    }
  }

  @Override
  public SystemPermissionDao systemPermissionDao() {
    if (_systemPermissionDao != null) {
      return _systemPermissionDao;
    } else {
      synchronized(this) {
        if(_systemPermissionDao == null) {
          _systemPermissionDao = new SystemPermissionDao_Impl(this);
        }
        return _systemPermissionDao;
      }
    }
  }

  @Override
  public CourseBlockPictureDao courseBlockPictureDao() {
    if (_courseBlockPictureDao != null) {
      return _courseBlockPictureDao;
    } else {
      synchronized(this) {
        if(_courseBlockPictureDao == null) {
          _courseBlockPictureDao = new CourseBlockPictureDao_Impl(this);
        }
        return _courseBlockPictureDao;
      }
    }
  }

  @Override
  public ContentEntryPicture2Dao contentEntryPicture2Dao() {
    if (_contentEntryPicture2Dao != null) {
      return _contentEntryPicture2Dao;
    } else {
      synchronized(this) {
        if(_contentEntryPicture2Dao == null) {
          _contentEntryPicture2Dao = new ContentEntryPicture2Dao_Impl(this);
        }
        return _contentEntryPicture2Dao;
      }
    }
  }

  @Override
  public TransferJobErrorDao transferJobErrorDao() {
    if (_transferJobErrorDao != null) {
      return _transferJobErrorDao;
    } else {
      synchronized(this) {
        if(_transferJobErrorDao == null) {
          _transferJobErrorDao = new TransferJobErrorDao_Impl(this);
        }
        return _transferJobErrorDao;
      }
    }
  }

  @Override
  public StudentResultDao studentResultDao() {
    if (_studentResultDao != null) {
      return _studentResultDao;
    } else {
      synchronized(this) {
        if(_studentResultDao == null) {
          _studentResultDao = new StudentResultDao_Impl(this);
        }
        return _studentResultDao;
      }
    }
  }

  @Override
  public VerbLangMapEntryDao verbLangMapEntryDao() {
    if (_verbLangMapEntryDao != null) {
      return _verbLangMapEntryDao;
    } else {
      synchronized(this) {
        if(_verbLangMapEntryDao == null) {
          _verbLangMapEntryDao = new VerbLangMapEntryDao_Impl(this);
        }
        return _verbLangMapEntryDao;
      }
    }
  }

  @Override
  public GroupMemberActorJoinDao groupMemberActorJoinDao() {
    if (_groupMemberActorJoinDao != null) {
      return _groupMemberActorJoinDao;
    } else {
      synchronized(this) {
        if(_groupMemberActorJoinDao == null) {
          _groupMemberActorJoinDao = new GroupMemberActorJoinDao_Impl(this);
        }
        return _groupMemberActorJoinDao;
      }
    }
  }

  @Override
  public ActivityLangMapEntryDao activityLangMapEntryDao() {
    if (_activityLangMapEntryDao != null) {
      return _activityLangMapEntryDao;
    } else {
      synchronized(this) {
        if(_activityLangMapEntryDao == null) {
          _activityLangMapEntryDao = new ActivityLangMapEntryDao_Impl(this);
        }
        return _activityLangMapEntryDao;
      }
    }
  }

  @Override
  public ActivityInteractionDao activityInteractionDao() {
    if (_activityInteractionDao != null) {
      return _activityInteractionDao;
    } else {
      synchronized(this) {
        if(_activityInteractionDao == null) {
          _activityInteractionDao = new ActivityInteractionDao_Impl(this);
        }
        return _activityInteractionDao;
      }
    }
  }

  @Override
  public ActivityExtensionDao activityExtensionDao() {
    if (_activityExtensionDao != null) {
      return _activityExtensionDao;
    } else {
      synchronized(this) {
        if(_activityExtensionDao == null) {
          _activityExtensionDao = new ActivityExtensionDao_Impl(this);
        }
        return _activityExtensionDao;
      }
    }
  }

  @Override
  public StatementContextActivityJoinDao statementContextActivityJoinDao() {
    if (_statementContextActivityJoinDao != null) {
      return _statementContextActivityJoinDao;
    } else {
      synchronized(this) {
        if(_statementContextActivityJoinDao == null) {
          _statementContextActivityJoinDao = new StatementContextActivityJoinDao_Impl(this);
        }
        return _statementContextActivityJoinDao;
      }
    }
  }

  @Override
  public XapiSessionEntityDao xapiSessionEntityDao() {
    if (_xapiSessionEntityDao != null) {
      return _xapiSessionEntityDao;
    } else {
      synchronized(this) {
        if(_xapiSessionEntityDao == null) {
          _xapiSessionEntityDao = new XapiSessionEntityDao_Impl(this);
        }
        return _xapiSessionEntityDao;
      }
    }
  }

  @Override
  public StatementEntityJsonDao statementEntityJsonDao() {
    if (_statementEntityJsonDao != null) {
      return _statementEntityJsonDao;
    } else {
      synchronized(this) {
        if(_statementEntityJsonDao == null) {
          _statementEntityJsonDao = new StatementEntityJsonDao_Impl(this);
        }
        return _statementEntityJsonDao;
      }
    }
  }

  @Override
  public PersonPasskeyDao personPasskeyDao() {
    if (_personPasskeyDao != null) {
      return _personPasskeyDao;
    } else {
      synchronized(this) {
        if(_personPasskeyDao == null) {
          _personPasskeyDao = new PersonPasskeyDao_Impl(this);
        }
        return _personPasskeyDao;
      }
    }
  }

  @Override
  public StateEntityDao stateEntityDao() {
    if (_stateEntityDao != null) {
      return _stateEntityDao;
    } else {
      synchronized(this) {
        if(_stateEntityDao == null) {
          _stateEntityDao = new StateEntityDao_Impl(this);
        }
        return _stateEntityDao;
      }
    }
  }

  @Override
  public StateDeleteCommandDao stateDeleteCommandDao() {
    if (_stateDeleteCommandDao != null) {
      return _stateDeleteCommandDao;
    } else {
      synchronized(this) {
        if(_stateDeleteCommandDao == null) {
          _stateDeleteCommandDao = new StateDeleteCommandDao_Impl(this);
        }
        return _stateDeleteCommandDao;
      }
    }
  }

  @Override
  public ClazzInviteDao clazzInviteDao() {
    if (_clazzInviteDao != null) {
      return _clazzInviteDao;
    } else {
      synchronized(this) {
        if(_clazzInviteDao == null) {
          _clazzInviteDao = new ClazzInviteDao_Impl(this);
        }
        return _clazzInviteDao;
      }
    }
  }
}
