@vue-skuilder/db 0.1.1

package/dist/index-QMtzQI65.d.ts

@@ -0,0 +1,734 @@
+import { CourseConfig, ClassroomConfig, CourseElo, Evaluation, Answer, Status, SkuilderCourseData as SkuilderCourseData$1, DataShape, ParsedCard } from '@vue-skuilder/common';
+import { Moment } from 'moment';
+
+/**
+ * Admin functionality
+ */
+interface AdminDBInterface {
+    /**
+     * Get all users
+     */
+    getUsers(): Promise<PouchDB.Core.Document<{}>[]>;
+    /**
+     * Get all courses
+     */
+    getCourses(): Promise<CourseConfig[]>;
+    /**
+     * Remove a course
+     */
+    removeCourse(id: string): Promise<PouchDB.Core.Response>;
+    /**
+     * Get all classrooms
+     */
+    getClassrooms(): Promise<(ClassroomConfig & {
+        _id: string;
+    })[]>;
+}
+
+interface UserConfig {
+    darkMode: boolean;
+    likesConfetti: boolean;
+}
+interface ActivityRecord {
+    timeStamp: number | string;
+    [key: string]: any;
+}
+interface CourseRegistration {
+    status?: 'active' | 'dropped' | 'maintenance-mode' | 'preview';
+    courseID: string;
+    admin: boolean;
+    moderator: boolean;
+    user: boolean;
+    settings?: {
+        [setting: string]: string | number | boolean;
+    };
+    elo: number | CourseElo;
+}
+interface StudyWeights {
+    [courseID: string]: number;
+}
+interface CourseRegistrationDoc {
+    courses: CourseRegistration[];
+    studyWeight: StudyWeights;
+}
+interface ScheduledCard {
+    _id: PouchDB.Core.DocumentId;
+    /**
+     * The docID of the card to be reviewed
+     */
+    cardId: PouchDB.Core.DocumentId;
+    /**
+     * The ID of the course
+     */
+    courseId: string;
+    /**
+     * The time at which the card becomes eligible for review.
+     *
+     * (Should probably be UTC adjusted so that performance is
+     * not wonky across time zones)
+     */
+    reviewTime: Moment;
+    /**
+     * The time at which this scheduled event was created.
+     */
+    scheduledAt: Moment;
+    /**
+     * Classifying whether this card is scheduled on behalf of a
+     * user-registered course or by as assigned content from a
+     * user-registered classroom
+     */
+    scheduledFor: 'course' | 'classroom';
+    /**
+     * The ID of the course or classroom that requested this card
+     */
+    schedulingAgentId: string;
+}
+
+type StudySessionFailedItem = StudySessionFailedNewItem | StudySessionFailedReviewItem;
+interface StudySessionFailedNewItem extends StudySessionItem {
+    status: 'failed-new';
+}
+interface StudySessionFailedReviewItem extends StudySessionReviewItem {
+    status: 'failed-review';
+}
+interface StudySessionNewItem extends StudySessionItem {
+    status: 'new';
+}
+interface StudySessionReviewItem extends StudySessionItem {
+    reviewID: string;
+    status: 'review' | 'failed-review';
+}
+declare function isReview(item: StudySessionItem): item is StudySessionReviewItem;
+interface StudySessionItem {
+    status: 'new' | 'review' | 'failed-new' | 'failed-review';
+    qualifiedID: `${string}-${string}` | `${string}-${string}-${number}`;
+    cardID: string;
+    contentSourceType: 'course' | 'classroom';
+    contentSourceID: string;
+    courseID: string;
+}
+interface ContentSourceID {
+    type: 'course' | 'classroom';
+    id: string;
+}
+interface StudyContentSource {
+    getPendingReviews(): Promise<(StudySessionReviewItem & ScheduledCard)[]>;
+    getNewCards(n?: number): Promise<StudySessionNewItem[]>;
+}
+declare function getStudySource(source: ContentSourceID, user: UserDBInterface): Promise<StudyContentSource>;
+
+/**
+ * Classroom management
+ */
+interface ClassroomDBInterface {
+    /**
+     * Get classroom config
+     */
+    getConfig(): ClassroomConfig;
+    /**
+     * Get assigned content
+     */
+    getAssignedContent(): Promise<AssignedContent[]>;
+}
+interface TeacherClassroomDBInterface extends ClassroomDBInterface {
+    /**
+     * For teacher interfaces: assign content
+     */
+    assignContent?(content: AssignedContent): Promise<boolean>;
+    /**
+     * For teacher interfaces: remove content
+     */
+    removeContent?(content: AssignedContent): Promise<void>;
+}
+interface StudentClassroomDBInterface extends ClassroomDBInterface {
+    /**
+     * For student interfaces: get pending reviews
+     */
+    getPendingReviews?(): Promise<(StudySessionReviewItem & ScheduledCard)[]>;
+    /**
+     * For student interfaces: get new cards
+     */
+    getNewCards?(limit?: number): Promise<StudySessionNewItem[]>;
+}
+type AssignedContent = AssignedCourse | AssignedTag | AssignedCard;
+interface AssignedTag extends ContentBase {
+    type: 'tag';
+    tagID: string;
+}
+interface AssignedCourse extends ContentBase {
+    type: 'course';
+}
+interface AssignedCard extends ContentBase {
+    type: 'card';
+    cardID: string;
+}
+interface ContentBase {
+    type: 'course' | 'tag' | 'card';
+    /**
+     * Username of the assigning teacher.
+     */
+    assignedBy: string;
+    /**
+     * Date the content was assigned.
+     */
+    assignedOn: moment.Moment;
+    /**
+     * A 'due' date for this assigned content, for scheduling content
+     * in advance. Content will not be actively pushed to students until
+     * this date.
+     */
+    activeOn: moment.Moment;
+    courseID: string;
+}
+
+declare const GuestUsername: string;
+declare const log: (message: string) => void;
+declare enum DocType {
+    DISPLAYABLE_DATA = "DISPLAYABLE_DATA",
+    CARD = "CARD",
+    DATASHAPE = "DATASHAPE",
+    QUESTIONTYPE = "QUESTION",
+    VIEW = "VIEW",
+    PEDAGOGY = "PEDAGOGY",
+    CARDRECORD = "CARDRECORD",
+    SCHEDULED_CARD = "SCHEDULED_CARD",
+    TAG = "TAG",
+    NAVIGATION_STRATEGY = "NAVIGATION_STRATEGY"
+}
+/**
+ * Interface for all data on course content and pedagogy stored
+ * in the c/pouch database.
+ */
+interface SkuilderCourseData {
+    course: string;
+    docType: DocType;
+}
+interface Tag extends SkuilderCourseData {
+    docType: DocType.TAG;
+    name: string;
+    snippet: string;
+    wiki: string;
+    taggedCards: PouchDB.Core.DocumentId[];
+}
+interface TagStub {
+    name: string;
+    snippet: string;
+    count: number;
+}
+interface CardData extends SkuilderCourseData {
+    docType: DocType.CARD;
+    id_displayable_data: PouchDB.Core.DocumentId[];
+    id_view: PouchDB.Core.DocumentId;
+    elo: CourseElo;
+}
+/** A list of populated courses in the DB */
+interface CourseListData extends PouchDB.Core.Response {
+    courses: string[];
+}
+/**
+ * The data used to hydrate viewable components (questions, info, etc)
+ */
+interface DisplayableData extends SkuilderCourseData {
+    docType: DocType.DISPLAYABLE_DATA;
+    author?: string;
+    id_datashape: PouchDB.Core.DocumentId;
+    data: Field[];
+    _attachments?: {
+        [index: string]: PouchDB.Core.FullAttachment;
+    };
+}
+interface Field {
+    data: unknown;
+    name: string;
+}
+interface DataShapeData extends SkuilderCourseData {
+    docType: DocType.DATASHAPE;
+    _id: PouchDB.Core.DocumentId;
+    questionTypes: PouchDB.Core.DocumentId[];
+}
+interface QuestionData extends SkuilderCourseData {
+    docType: DocType.QUESTIONTYPE;
+    _id: PouchDB.Core.DocumentId;
+    viewList: string[];
+    dataShapeList: PouchDB.Core.DocumentId[];
+}
+declare const cardHistoryPrefix = "cardH";
+interface CardHistory<T extends CardRecord> {
+    _id: PouchDB.Core.DocumentId;
+    /**
+     * The CouchDB id of the card
+     */
+    cardID: PouchDB.Core.DocumentId;
+    /**
+     * The ID of the course
+     */
+    courseID: string;
+    /**
+     * The to-date largest interval between successful
+     * card reviews. `0` indicates no successful reviews.
+     */
+    bestInterval: number;
+    /**
+     * The number of times that a card has been
+     * failed in review
+     */
+    lapses: number;
+    /**
+     * The number of consecutive successful impressions
+     * on this card
+     */
+    streak: number;
+    records: T[];
+}
+interface CardRecord {
+    /**
+     * The CouchDB id of the card
+     */
+    cardID: string;
+    /**
+     * The ID of the course
+     */
+    courseID: string;
+    /**
+     * Number of milliseconds that the user spent before dismissing
+     * the card (ie, "I've read this" or "here is my answer")
+     *
+     * //TODO: this (sometimes?) wants to be replaced with a rich
+     *         recording of user activity in working the question
+     */
+    timeSpent: number;
+    /**
+     * The date-time that the card was rendered. timeStamp + timeSpent will give the
+     * time of user submission.
+     */
+    timeStamp: Moment;
+}
+interface QuestionRecord extends CardRecord, Evaluation {
+    userAnswer: Answer;
+    /**
+     * The number of incorrect user submissions prededing this submisstion.
+     *
+     * eg, if a user is asked 7*6=__, submitting 46, 48, 42 will result in three
+     * records being created having 0, 1, and 2 as their recorded 'priorAttempts' values
+     */
+    priorAttemps: number;
+}
+
+interface DataLayerResult {
+    status: Status;
+    message: string;
+    id?: string;
+}
+
+/**
+ *
+ */
+interface ContentNavigationStrategyData extends SkuilderCourseData {
+    id: string;
+    docType: DocType.NAVIGATION_STRATEGY;
+    name: string;
+    description: string;
+    /**
+     The name of the class that implements the navigation strategy at runtime.
+     */
+    implementingClass: string;
+    /**
+     A representation of the strategy's parameterization - to be deserialized
+     by the implementing class's constructor at runtime.
+    */
+    serializedData: string;
+}
+
+/**
+ * A NavigationStrategyManager is an entity which may contain multiple strategies.
+ *
+ * This interface defines strategy CRUD.
+ */
+interface NavigationStrategyManager {
+    /**
+     * Get the navigation strategy for a given course
+     * @returns The navigation strategy for the course
+     */
+    getNavigationStrategy(id: string): Promise<ContentNavigationStrategyData>;
+    /**
+     * Get all available navigation strategies
+     * @returns An array of all available navigation strategies
+     */
+    getAllNavigationStrategies(): Promise<ContentNavigationStrategyData[]>;
+    /**
+     * Add a new navigation strategy
+     * @param data The data for the new navigation strategy
+     * @returns A promise that resolves when the strategy has been added
+     */
+    addNavigationStrategy(data: ContentNavigationStrategyData): Promise<void>;
+    /**
+     * Update an existing navigation strategy
+     * @param id The ID of the navigation strategy to update
+     * @param data The new data for the navigation strategy
+     * @returns A promise that resolves when the update is complete
+     */
+    updateNavigationStrategy(id: string, data: ContentNavigationStrategyData): Promise<void>;
+    /**
+     * @returns A content navigation strategy suitable to the current context.
+     */
+    surfaceNavigationStrategy(): Promise<ContentNavigationStrategyData>;
+}
+
+/**
+ * Course content and management
+ */
+interface CoursesDBInterface {
+    /**
+     * Get course config
+     */
+    getCourseConfig(courseId: string): Promise<CourseConfig>;
+    /**
+     * Get a list of all courses
+     */
+    getCourseList(): Promise<CourseConfig[]>;
+    disambiguateCourse(courseId: string, disambiguator: string): Promise<void>;
+}
+interface CourseInfo {
+    cardCount: number;
+    registeredUsers: number;
+}
+interface CourseDBInterface extends NavigationStrategyManager {
+    /**
+     * Get course config
+     */
+    getCourseConfig(): Promise<CourseConfig>;
+    getCourseID(): string;
+    /**
+     * Set course config
+     */
+    updateCourseConfig(cfg: CourseConfig): Promise<PouchDB.Core.Response>;
+    getCourseInfo(): Promise<CourseInfo>;
+    getCourseDoc<T extends SkuilderCourseData$1>(id: string, options?: PouchDB.Core.GetOptions): Promise<T>;
+    getCourseDocs<T extends SkuilderCourseData$1>(ids: string[], options?: PouchDB.Core.AllDocsOptions): Promise<PouchDB.Core.AllDocsWithKeysResponse<{} & T>>;
+    /**
+     * Get cards sorted by ELO rating
+     */
+    getCardsByELO(elo: number, limit?: number): Promise<string[]>;
+    /**
+     * Get ELO data for specific cards
+     */
+    getCardEloData(cardIds: string[]): Promise<CourseElo[]>;
+    /**
+     * Update card ELO rating
+     */
+    updateCardElo(cardId: string, elo: CourseElo): Promise<PouchDB.Core.Response>;
+    /**
+     * Get new cards for study
+     */
+    getNewCards(limit?: number): Promise<StudySessionNewItem[]>;
+    /**
+     * Get cards centered at a particular ELO rating
+     */
+    getCardsCenteredAtELO(options: {
+        limit: number;
+        elo: 'user' | 'random' | number;
+    }, filter?: (id: string) => boolean): Promise<StudySessionItem[]>;
+    /**
+     * Get tags for a card
+     */
+    getAppliedTags(cardId: string): Promise<PouchDB.Query.Response<TagStub>>;
+    /**
+     * Add a tag to a card
+     */
+    addTagToCard(cardId: string, tagId: string, updateELO?: boolean): Promise<PouchDB.Core.Response>;
+    /**
+     * Remove a tag from a card
+     */
+    removeTagFromCard(cardId: string, tagId: string): Promise<PouchDB.Core.Response>;
+    /**
+     * Create a new tag
+     */
+    createTag(tagName: string): Promise<PouchDB.Core.Response>;
+    /**
+     * Get a tag by name
+     */
+    getTag(tagName: string): Promise<Tag>;
+    /**
+     * Update a tag
+     */
+    updateTag(tag: Tag): Promise<PouchDB.Core.Response>;
+    /**
+     * Get all tag stubs for a course
+     */
+    getCourseTagStubs(): Promise<PouchDB.Core.AllDocsResponse<Tag>>;
+    /**
+     * Add a note to the course
+     */
+    addNote(codeCourse: string, shape: DataShape, data: unknown, author: string, tags: string[], uploads?: {
+        [key: string]: PouchDB.Core.FullAttachment;
+    }, elo?: CourseElo): Promise<DataLayerResult>;
+    removeCard(cardId: string): Promise<PouchDB.Core.Response>;
+    getInexperiencedCards(): Promise<{
+        courseId: string;
+        cardId: string;
+        count: number;
+        elo: CourseElo;
+    }[]>;
+}
+
+declare abstract class Loggable {
+    protected abstract readonly _className: string;
+    protected log(...args: unknown[]): void;
+    protected error(...args: unknown[]): void;
+}
+
+type Update<T> = Partial<T> | ((x: T) => T);
+
+interface DocumentUpdater {
+    update<T extends PouchDB.Core.Document<object>>(id: string, update: Update<T>): Promise<T>;
+}
+/**
+ * Returns the minimum number of seconds that should pass before a
+ * card is redisplayed for review / practice.
+ *
+ * @param cardHistory The user's history working with the given card
+ */
+declare function newInterval(user: DocumentUpdater, cardHistory: CardHistory<CardRecord>): number;
+
+/**
+ * User data and authentication
+ */
+interface UserDBInterface extends DocumentUpdater {
+    /**
+     * Create a new user account
+     */
+    createAccount(username: string, password: string): Promise<{
+        status: Status;
+        error: string;
+    }>;
+    /**
+     * Log in as a user
+     */
+    login(username: string, password: string): Promise<{
+        ok: boolean;
+        name?: string;
+        roles?: string[];
+    }>;
+    /**
+     * Log out the current user
+     */
+    logout(): Promise<{
+        ok: boolean;
+    }>;
+    getUsername(): string;
+    isLoggedIn(): boolean;
+    /**
+     * Get user configuration
+     */
+    getConfig(): Promise<UserConfig>;
+    /**
+     * Update user configuration
+     */
+    setConfig(config: Partial<UserConfig>): Promise<void>;
+    /**
+     * Record a user's interaction with a card
+     */
+    putCardRecord<T extends CardRecord>(record: T): Promise<CardHistory<CardRecord>>;
+    /**
+     * Get cards that the user has seen
+     */
+    getSeenCards(courseId?: string): Promise<string[]>;
+    /**
+     * Get cards that are actively scheduled for review
+     */
+    getActiveCards(): Promise<string[]>;
+    /**
+     * Register user for a course
+     */
+    registerForCourse(courseId: string, previewMode?: boolean): Promise<PouchDB.Core.Response>;
+    /**
+     * Drop a course registration
+     */
+    dropCourse(courseId: string, dropStatus?: string): Promise<PouchDB.Core.Response>;
+    /**
+     * Get user's course registrations
+     */
+    getCourseRegistrationsDoc(): Promise<CourseRegistrationDoc>;
+    /**
+     * Get the registration doc for a specific course.
+     * @param courseId
+     */
+    getCourseRegDoc(courseId: string): Promise<CourseRegistration>;
+    /**
+     * Get user's active courses
+     */
+    getActiveCourses(): Promise<CourseRegistration[]>;
+    /**
+     * Get user's pending reviews
+     */
+    getPendingReviews(courseId?: string): Promise<ScheduledCard[]>;
+    getActivityRecords(): Promise<ActivityRecord[]>;
+    /**
+     * Schedule a card for review
+     */
+    scheduleCardReview(review: {
+        user: string;
+        course_id: string;
+        card_id: string;
+        time: Moment;
+        scheduledFor: 'course' | 'classroom';
+        schedulingAgentId: string;
+    }): Promise<void>;
+    /**
+     * Remove a scheduled card review
+     */
+    removeScheduledCardReview(reviewId: string): Promise<void>;
+    /**
+     * Register user for a classroom
+     */
+    registerForClassroom(classId: string, registerAs: 'student' | 'teacher' | 'aide' | 'admin'): Promise<PouchDB.Core.Response>;
+    /**
+     * Drop user from classroom
+     */
+    dropFromClassroom(classId: string): Promise<PouchDB.Core.Response>;
+    /**
+     * Get user's classroom registrations
+     */
+    getUserClassrooms(): Promise<ClassroomRegistrationDoc>;
+    /**
+     * Get user's active classes
+     */
+    getActiveClasses(): Promise<string[]>;
+    /**
+     * Update user's ELO rating for a course
+     */
+    updateUserElo(courseId: string, elo: CourseElo): Promise<PouchDB.Core.Response>;
+    getCourseInterface(courseId: string): Promise<UsrCrsDataInterface>;
+}
+interface UserCourseSettings {
+    [setting: string]: string | number | boolean;
+}
+interface UserCourseSetting {
+    key: string;
+    value: string | number | boolean;
+}
+interface UsrCrsDataInterface {
+    getScheduledReviewCount(): Promise<number>;
+    getCourseSettings(): Promise<UserCourseSettings>;
+    updateCourseSettings(updates: UserCourseSetting[]): void;
+}
+type ClassroomRegistrationDesignation = 'student' | 'teacher' | 'aide' | 'admin';
+interface ClassroomRegistration {
+    classID: string;
+    registeredAs: ClassroomRegistrationDesignation;
+}
+interface ClassroomRegistrationDoc {
+    registrations: ClassroomRegistration[];
+}
+
+/**
+ * Main factory interface for data access
+ */
+interface DataLayerProvider {
+    /**
+     * Get the user database interface
+     */
+    getUserDB(): UserDBInterface;
+    /**
+     * Get a course database interface
+     */
+    getCourseDB(courseId: string): CourseDBInterface;
+    /**
+     * Get the courses-lookup interface
+     */
+    getCoursesDB(): CoursesDBInterface;
+    /**
+     * Get a classroom database interface
+     */
+    getClassroomDB(classId: string, type: 'student' | 'teacher'): Promise<ClassroomDBInterface>;
+    /**
+     * Get the admin database interface
+     */
+    getAdminDB(): AdminDBInterface;
+    /**
+     * Initialize the data layer
+     */
+    initialize(): Promise<void>;
+    /**
+     * Teardown the data layer
+     */
+    teardown(): Promise<void>;
+}
+
+declare function areQuestionRecords(h: CardHistory<CardRecord>): h is CardHistory<QuestionRecord>;
+declare function isQuestionRecord(c: CardRecord): c is QuestionRecord;
+declare function getCardHistoryID(courseID: string, cardID: string): PouchDB.Core.DocumentId;
+declare function parseCardHistoryID(id: string): {
+    courseID: string;
+    cardID: string;
+};
+interface PouchDBError extends Error {
+    error?: string;
+    reason?: string;
+}
+declare function docIsDeleted(e: PouchDBError): boolean;
+
+declare enum Navigators {
+    ELO = "elo"
+}
+/**
+ * A content-navigator provides runtime steering of study sessions.
+ */
+declare abstract class ContentNavigator implements StudyContentSource {
+    /**
+     *
+     * @param user
+     * @param strategyData
+     * @returns the runtime object used to steer a study session.
+     */
+    static create(user: UserDBInterface, course: CourseDBInterface, strategyData: ContentNavigationStrategyData): Promise<ContentNavigator>;
+    abstract getPendingReviews(): Promise<(StudySessionReviewItem & ScheduledCard)[]>;
+    abstract getNewCards(n?: number): Promise<StudySessionNewItem[]>;
+}
+
+/**
+ * Interface representing the result of a bulk import operation for a single card
+ */
+interface ImportResult {
+    /** The original text input for the card */
+    originalText: string;
+    /** Status of the import operation */
+    status: 'success' | 'error';
+    /** Message describing the result or error */
+    message: string;
+    /** ID of the newly created card (only for success) */
+    cardId?: string;
+}
+/**
+ * Configuration for the bulk card processor
+ */
+interface BulkCardProcessorConfig {
+    /** The data shape to use for the cards */
+    dataShape: DataShape;
+    /** The course code used for adding notes */
+    courseCode: string;
+    /** The username of the current user */
+    userName: string;
+}
+
+/**
+ * Processes multiple cards from bulk text input
+ *
+ * @param parsedCards - Array of parsed cards to import
+ * @param courseDB - Course database interface
+ * @param config - Configuration for the card processor
+ * @returns Array of import results
+ */
+declare function importParsedCards(parsedCards: ParsedCard[], courseDB: CourseDBInterface, config: BulkCardProcessorConfig): Promise<ImportResult[]>;
+/**
+ * Validates the configuration for bulk card processing
+ *
+ * @param config - Configuration to validate
+ * @returns Object with validation result and error message if any
+ */
+declare function validateProcessorConfig(config: Partial<BulkCardProcessorConfig>): {
+    isValid: boolean;
+    errorMessage?: string;
+};
+
+export { getCardHistoryID as $, type AdminDBInterface as A, type SkuilderCourseData as B, type CardRecord as C, type DataLayerProvider as D, type Tag as E, type TagStub as F, GuestUsername as G, type CardData as H, type CourseListData as I, type DisplayableData as J, type Field as K, Loggable as L, type DataShapeData as M, cardHistoryPrefix as N, type CardHistory as O, type QuestionRecord as P, type QuestionData as Q, type UserConfig as R, type StudySessionItem as S, type TeacherClassroomDBInterface as T, type UserDBInterface as U, type ActivityRecord as V, type CourseRegistration as W, type CourseRegistrationDoc as X, type ScheduledCard as Y, areQuestionRecords as Z, isQuestionRecord as _, type StudyContentSource as a, parseCardHistoryID as a0, docIsDeleted as a1, Navigators as a2, ContentNavigator as a3, importParsedCards as a4, validateProcessorConfig as a5, type ImportResult as a6, type BulkCardProcessorConfig as a7, type DocumentUpdater as a8, newInterval as a9, type ClassroomDBInterface as b, type StudentClassroomDBInterface as c, type AssignedContent as d, type AssignedTag as e, type AssignedCourse as f, type AssignedCard as g, type StudySessionFailedItem as h, type StudySessionFailedNewItem as i, type StudySessionFailedReviewItem as j, type StudySessionNewItem as k, type StudySessionReviewItem as l, isReview as m, type ContentSourceID as n, getStudySource as o, type CoursesDBInterface as p, type CourseInfo as q, type CourseDBInterface as r, type UserCourseSettings as s, type UserCourseSetting as t, type UsrCrsDataInterface as u, type ClassroomRegistrationDesignation as v, type ClassroomRegistration as w, type ClassroomRegistrationDoc as x, log as y, DocType as z };