@aastrika_npmjs/sunbird-sdk 5.1.1

package/sdk.d.ts

@@ -0,0 +1,91 @@
+import { ApiService } from './api';
+import { DbService } from './db';
+import { AuthService } from './auth';
+import { TelemetryService } from './telemetry';
+import { SharedPreferences } from './util/shared-preferences';
+import { SdkConfig } from './sdk-config';
+import { ContentFeedbackService, ContentService, ContentServiceConfig } from './content';
+import { CourseService } from './course';
+import { FormService } from './form';
+import { FrameworkService, FrameworkUtilService } from './framework';
+import { ProfileService } from './profile';
+import { KeyValueStore } from './key-value-store';
+import { PageAssembleService, PageServiceConfig } from './page';
+import { SystemSettingsService } from './system-settings';
+import { DeviceInfo } from './util/device';
+import { EventsBusService } from './events-bus';
+import { SummarizerService } from './summarizer';
+import { DownloadService } from './util/download';
+import { AppInfo } from './util/app';
+import { PlayerService } from './player';
+import { TelemetryConfig } from './telemetry/config/telemetry-config';
+import { StorageService } from './storage';
+import { NotificationService } from './notification';
+import { ErrorLoggerService } from './error';
+import { NetworkInfoService } from './util/network';
+import { SearchHistoryService } from './util/search-history';
+import { CodePushExperimentService } from './codepush-experiment';
+import { FaqService } from './faq';
+import { DeviceRegisterConfig, DeviceRegisterService } from './device-register';
+import { ArchiveService } from './archive';
+import { NetworkQueue } from './api/network-queue';
+import { GroupService } from './group';
+import { GroupServiceDeprecated } from './group-deprecated';
+import { DiscussionService } from './discussion';
+import { SegmentationService } from './segmentation';
+import { DebuggingService } from './debugging';
+import { NotificationServiceV2 } from './notification-v2/def/notification-service-v2';
+import { CertificateService } from './certificate';
+export declare class SunbirdSdk {
+    private _container;
+    private static _instance?;
+    static readonly instance: SunbirdSdk;
+    private _isInitialised;
+    readonly isInitialised: boolean;
+    readonly sdkConfig: SdkConfig;
+    readonly appInfo: AppInfo;
+    readonly pageAssembleService: PageAssembleService;
+    readonly dbService: DbService;
+    readonly telemetryService: TelemetryService;
+    readonly authService: AuthService;
+    readonly apiService: ApiService;
+    readonly keyValueStore: KeyValueStore;
+    readonly profileService: ProfileService;
+    readonly groupService: GroupService;
+    readonly groupServiceDeprecated: GroupServiceDeprecated;
+    readonly contentService: ContentService;
+    readonly contentFeedbackService: ContentFeedbackService;
+    readonly courseService: CourseService;
+    readonly formService: FormService;
+    readonly frameworkService: FrameworkService;
+    readonly frameworkUtilService: FrameworkUtilService;
+    readonly sharedPreferences: SharedPreferences;
+    readonly systemSettingsService: SystemSettingsService;
+    readonly eventsBusService: EventsBusService;
+    readonly summarizerService: SummarizerService;
+    readonly downloadService: DownloadService;
+    readonly playerService: PlayerService;
+    readonly deviceInfo: DeviceInfo;
+    readonly storageService: StorageService;
+    readonly notificationService: NotificationService;
+    readonly errorLoggerService: ErrorLoggerService;
+    readonly networkInfoService: NetworkInfoService;
+    readonly searchHistoryService: SearchHistoryService;
+    readonly codePushExperimentService: CodePushExperimentService;
+    readonly faqService: FaqService;
+    readonly deviceRegisterService: DeviceRegisterService;
+    readonly archiveService: ArchiveService;
+    readonly networkQueueService: NetworkQueue;
+    readonly discussionService: DiscussionService;
+    readonly segmentationService: SegmentationService;
+    readonly debuggingService: DebuggingService;
+    readonly notificationServiceV2: NotificationServiceV2;
+    readonly certificateService: CertificateService;
+    init(sdkConfig: SdkConfig): Promise<void>;
+    updateTelemetryConfig(update: Partial<TelemetryConfig>): void;
+    updateDeviceRegisterConfig(update: Partial<DeviceRegisterConfig>): void;
+    updateContentServiceConfig(update: Partial<ContentServiceConfig>): void;
+    updatePageServiceConfig(update: Partial<PageServiceConfig>): void;
+    private preInit;
+    private postInit;
+}

package/segmentation/def/segmentation-service.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from "rxjs";
+export interface SegmentationService {
+    saveTags(tags: string, userId: string): Observable<boolean>;
+    getTags(userId: string): Observable<any>;
+    removeTagsForId(userid: string): Observable<string>;
+    clearAllTags(): Observable<string>;
+    saveCommandList(commandList: string, userId: string): Observable<any>;
+    getCommand(userId: string): Observable<any>;
+}

package/segmentation/handler/fetch-segmentation-command-handler.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import { KeyValueStore } from "../../key-value-store";
+export declare class FetchSegmentationCommandHandler {
+    private keyValueStore;
+    private COMMAND_KEY;
+    constructor(keyValueStore: KeyValueStore);
+    handle(userId: string): Observable<any>;
+}

package/segmentation/handler/fetch-segmentation-tags-handler.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import { KeyValueStore } from "../../key-value-store";
+export declare class FetchSegmentationTagHandler {
+    private keyValueStore;
+    private TAG_KEY;
+    constructor(keyValueStore: KeyValueStore);
+    handle(userId: string): Observable<any>;
+}

package/segmentation/handler/store-segmentation-command-handler.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import { KeyValueStore } from "../../key-value-store";
+export declare class StoreSegmentationCommandHandler {
+    private keyValueStore;
+    private COMMAND_KEY;
+    constructor(keyValueStore: KeyValueStore);
+    handle(commandList: any, userId: any): Observable<boolean>;
+}

package/segmentation/handler/store-segmentation-tag-handler.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import { KeyValueStore } from "../../key-value-store";
+export declare class StoreSegmentationTagHandler {
+    private keyValueStore;
+    private TAG_KEY;
+    constructor(keyValueStore: KeyValueStore);
+    handle(tags: string, userId: string): Observable<boolean>;
+}

package/segmentation/impl/segmentaion-service-impl.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from "rxjs";
+import { KeyValueStore } from "../../key-value-store";
+import { SegmentationService } from "../def/segmentation-service";
+export declare class SegmentationServiceImpl implements SegmentationService {
+    private keyValueStore;
+    constructor(keyValueStore: KeyValueStore);
+    saveTags(tags: string, userId: string): Observable<boolean>;
+    getTags(userId: string): Observable<any>;
+    removeTagsForId(userid: string): Observable<string>;
+    clearAllTags(): Observable<string>;
+    saveCommandList(commandList: any, userId: any): Observable<any>;
+    getCommand(userId: any): Observable<any>;
+}

package/segmentation/index.d.ts

@@ -0,0 +1,6 @@
+export * from './def/segmentation-service';
+export * from './handler/fetch-segmentation-tags-handler';
+export * from './handler/fetch-segmentation-command-handler';
+export * from './handler/store-segmentation-tag-handler';
+export * from './handler/store-segmentation-command-handler';
+export * from './impl/segmentaion-service-impl';

package/storage/def/scan-requests.d.ts

@@ -0,0 +1,5 @@
+export interface ScanContentContext {
+    currentStoragePath: string;
+    newlyAddedIdentifiers?: string[];
+    deletedIdentifiers?: string[];
+}

package/storage/def/storage-destination.d.ts

@@ -0,0 +1,4 @@
+export declare enum StorageDestination {
+    INTERNAL_STORAGE = "INTERNAL_STORAGE",
+    EXTERNAL_STORAGE = "EXTERNAL_STORAGE"
+}

package/storage/def/storage-event.d.ts

@@ -0,0 +1,36 @@
+import { EventsBusEvent } from '../../events-bus';
+export interface StorageEvent extends EventsBusEvent {
+    type: StorageEventType;
+}
+export interface StorageTransferProgress extends StorageEvent {
+    type: StorageEventType.TRANSFER_PROGRESS;
+    payload: {
+        progress: {
+            transferredCount: number;
+            totalCount: number;
+        };
+    };
+}
+export interface StorageTransferCompleted extends StorageEvent {
+    type: StorageEventType.TRANSFER_COMPLETED;
+    payload: undefined;
+}
+export interface StorageTransferRevertCompleted extends StorageEvent {
+    type: StorageEventType.TRANSFER_REVERT_COMPLETED;
+    payload: undefined;
+}
+export interface StorageTransferFailedDuplicateContent extends StorageEvent {
+    type: StorageEventType.TRANSFER_FAILED_DUPLICATE_CONTENT;
+    payload: undefined;
+}
+export interface StorageTransferFailedLowMemory extends StorageEvent {
+    type: StorageEventType.TRANSFER_FAILED_LOW_MEMORY;
+    payload: undefined;
+}
+export declare enum StorageEventType {
+    TRANSFER_PROGRESS = "TRANSFER_PROGRESS",
+    TRANSFER_COMPLETED = "TRANSFER_COMPLETED",
+    TRANSFER_REVERT_COMPLETED = "TRANSFER_REVERT_COMPLETED",
+    TRANSFER_FAILED_DUPLICATE_CONTENT = "TRANSFER_FAILED_DUPLICATE_CONTENT",
+    TRANSFER_FAILED_LOW_MEMORY = "TRANSFER_FAILED_LOW_MEMORY"
+}

package/storage/def/storage-requests.d.ts

@@ -0,0 +1,15 @@
+export declare enum ExistingContentAction {
+    IGNORE = "IGNORE",
+    KEEP_HIGER_VERSION = "KEEP_HIGER_VERSION",
+    KEEP_LOWER_VERSION = "KEEP_LOWER_VERSION",
+    KEEP_SOURCE = "KEEP_SOURCE",
+    KEEP_DESTINATION = "KEEP_DESTINATION"
+}
+export interface TransferContentsRequest {
+    contentIds: string[];
+    existingContentAction: ExistingContentAction;
+    destinationFolder: string;
+    sourceFolder?: string;
+    deleteDestination: boolean;
+    shouldMergeInDestination?: boolean;
+}

package/storage/def/storage-service.d.ts

@@ -0,0 +1,16 @@
+import { StorageDestination } from './storage-destination';
+import { Observable } from 'rxjs';
+import { Content, StorageVolume } from '../..';
+import { TransferContentsRequest } from './storage-requests';
+import { SdkServiceOnInitDelegate } from '../../sdk-service-on-init-delegate';
+export interface StorageService extends SdkServiceOnInitDelegate {
+    getStorageDestinationDirectoryPath(): string | undefined;
+    getStorageDestinationVolumeInfo(): Observable<StorageVolume>;
+    getStorageDestination(): Observable<StorageDestination>;
+    getToTransferContents(): Observable<Content[]>;
+    getTransferringContent(): Observable<Content | undefined>;
+    transferContents(transferContentsRequest: TransferContentsRequest): Observable<undefined>;
+    scanStorage(): Observable<boolean>;
+    cancelTransfer(): Observable<undefined>;
+    retryCurrentTransfer(): Observable<undefined>;
+}

package/storage/errors/cancellation-error.d.ts

@@ -0,0 +1,4 @@
+import { SunbirdError } from '../../sunbird-error';
+export declare class CancellationError extends SunbirdError {
+    constructor(message: string);
+}

package/storage/errors/duplicate-content-error.d.ts

@@ -0,0 +1,4 @@
+import { SunbirdError } from '../../sunbird-error';
+export declare class DuplicateContentError extends SunbirdError {
+    constructor(message: string);
+}

package/storage/errors/low-memory-error.d.ts

@@ -0,0 +1,4 @@
+import { SunbirdError } from '../../sunbird-error';
+export declare class LowMemoryError extends SunbirdError {
+    constructor(message: string);
+}

package/storage/errors/transfer-failed-duplicate-content-error.d.ts

@@ -0,0 +1,4 @@
+import { SunbirdError } from '../../sunbird-error';
+export declare class TransferFailedDuplicateContentError extends SunbirdError {
+    constructor(message: string);
+}

package/storage/errors/transfer-failed-error.d.ts

@@ -0,0 +1,5 @@
+import { SunbirdError } from '../../sunbird-error';
+export declare class TransferFailedError extends SunbirdError {
+    readonly directory: string;
+    constructor(message: string, directory: string);
+}

package/storage/handler/scan/get-modified-content-handler.d.ts

@@ -0,0 +1,15 @@
+import { FileService } from '../../../util/file/def/file-service';
+import { ScanContentContext } from '../../def/scan-requests';
+import { DbService } from '../../../db';
+import { Observable } from 'rxjs';
+export declare class GetModifiedContentHandler {
+    private fileService;
+    private dbService;
+    constructor(fileService: FileService, dbService: DbService);
+    execute(context: ScanContentContext): Observable<ScanContentContext>;
+    private doesDestinationStorageExist;
+    private getContentsInDb;
+    private getNewlyAddedContents;
+    private getDeletedContents;
+    private getFolderList;
+}

package/storage/handler/scan/perform-actoin-on-content-handler.d.ts

@@ -0,0 +1,8 @@
+import { ScanContentContext } from '../../def/scan-requests';
+import { StorageHandler } from '../storage-handler';
+import { Observable } from 'rxjs';
+export declare class PerformActoinOnContentHandler {
+    private storageHandler;
+    constructor(storageHandler: StorageHandler);
+    exexute(context: ScanContentContext): Observable<ScanContentContext>;
+}

package/storage/handler/storage-handler.d.ts

@@ -0,0 +1,14 @@
+import { AppConfig } from '../../api/config/app-config';
+import { FileService } from '../../util/file/def/file-service';
+import { DbService } from '../../db';
+import { DeviceInfo } from '../../util/device';
+export declare class StorageHandler {
+    private appConfig;
+    private fileService;
+    private dbService;
+    private deviceInfo;
+    constructor(appConfig: AppConfig, fileService: FileService, dbService: DbService, deviceInfo: DeviceInfo);
+    addDestinationContentInDb(identifier: string, storageFolder: string, keepLowerVersion: boolean): Promise<void>;
+    deleteContentsFromDb(deletedIdentifiers: string[]): Promise<void>;
+    private extractContentFromItem;
+}

package/storage/handler/transfer/copy-content-from-source-to-destination.d.ts

@@ -0,0 +1,15 @@
+import { TransferContentContext } from '../transfer-content-handler';
+import { EventsBusService } from '../../../events-bus';
+import { Observable } from 'rxjs';
+export declare class CopyContentFromSourceToDestination {
+    private eventsBusService;
+    private contentsTransferred;
+    constructor(eventsBusService: EventsBusService);
+    execute(context: TransferContentContext): Observable<TransferContentContext>;
+    private emitContentTransferProgress;
+    private deleteFolder;
+    private copyFolder;
+    private renameFolder;
+    private copyToTempDestination;
+    private removeSourceAndDestination;
+}

package/storage/handler/transfer/delete-destination-folder.d.ts

@@ -0,0 +1,6 @@
+import { Observable } from 'rxjs';
+import { TransferContentContext } from '../transfer-content-handler';
+export declare class DeleteDestinationFolder {
+    constructor();
+    execute(context: TransferContentContext): Observable<TransferContentContext>;
+}

package/storage/handler/transfer/delete-source-folder.d.ts

@@ -0,0 +1,12 @@
+import { TransferContentContext } from '../transfer-content-handler';
+import { EventsBusService } from '../../../events-bus';
+import { Observable } from 'rxjs';
+export declare class DeleteSourceFolder {
+    private eventsBusService;
+    constructor(eventsBusService: EventsBusService);
+    execute(context: TransferContentContext): Observable<TransferContentContext>;
+    private deleteFolder;
+    private copyFolder;
+    private renameFolder;
+    private removeSourceAndDestination;
+}

package/storage/handler/transfer/device-memory-check.d.ts

@@ -0,0 +1,9 @@
+import { TransferContentContext } from '../transfer-content-handler';
+import { DbService } from '../../../db';
+import { Observable } from 'rxjs';
+export declare class DeviceMemoryCheck {
+    private dbService;
+    constructor(dbService: DbService);
+    execute(context: TransferContentContext): Observable<TransferContentContext>;
+    private getFreeUsableSpace;
+}

package/storage/handler/transfer/duplicate-content-check.d.ts

@@ -0,0 +1,13 @@
+import { DbService } from '../../../db';
+import { TransferContentContext } from '../transfer-content-handler';
+import { FileService } from '../../../util/file/def/file-service';
+import { Observable } from 'rxjs';
+export declare class DuplicateContentCheck {
+    private dbService;
+    private fileService;
+    constructor(dbService: DbService, fileService: FileService);
+    execute(context: TransferContentContext): Observable<TransferContentContext>;
+    private getContentsInDb;
+    private getPkgVersionFromFile;
+    private generateMoveContentResponses;
+}

package/storage/handler/transfer/store-destination-content-in-db.d.ts

@@ -0,0 +1,17 @@
+import { FileService } from '../../../util/file/def/file-service';
+import { TransferContentContext } from '../transfer-content-handler';
+import { DbService } from '../../../db';
+import { AppConfig } from '../../../api/config/app-config';
+import { DeviceInfo } from '../../../util/device';
+import { Observable } from 'rxjs';
+export declare class StoreDestinationContentInDb {
+    private appConfig;
+    private fileService;
+    private dbService;
+    private deviceInfo;
+    constructor(appConfig: AppConfig, fileService: FileService, dbService: DbService, deviceInfo: DeviceInfo);
+    execute(context: TransferContentContext): Observable<void>;
+    private getNewlyAddedContents;
+    private addDestinationContentInDb;
+    private extractContentFromItem;
+}

package/storage/handler/transfer/update-source-content-path-in-db.d.ts

@@ -0,0 +1,8 @@
+import { TransferContentContext } from '../transfer-content-handler';
+import { DbService } from '../../../db';
+import { Observable } from 'rxjs';
+export declare class UpdateSourceContentPathInDb {
+    private dbService;
+    constructor(dbService: DbService);
+    execute(context: TransferContentContext): Observable<TransferContentContext>;
+}

package/storage/handler/transfer/validate-destination-content.d.ts

@@ -0,0 +1,13 @@
+import { FileService } from '../../../util/file/def/file-service';
+import { AppConfig } from '../../../api/config/app-config';
+import { TransferContentContext } from '../transfer-content-handler';
+import { Observable } from 'rxjs';
+export declare class ValidateDestinationContent {
+    private fileService;
+    private appConfig;
+    constructor(fileService: FileService, appConfig: AppConfig);
+    execute(context: TransferContentContext): Observable<TransferContentContext>;
+    private getSubdirectoriesEntries;
+    private extractValidContentIdsInDestination;
+    private extractManifest;
+}

package/storage/handler/transfer/validate-destination-folder.d.ts

@@ -0,0 +1,11 @@
+import { TransferContentContext } from '../transfer-content-handler';
+import { FileService } from '../../../util/file/def/file-service';
+import { Observable } from 'rxjs';
+export declare class ValidateDestinationFolder {
+    private fileService;
+    constructor(fileService: FileService);
+    execute(context: TransferContentContext): Observable<TransferContentContext>;
+    private validate;
+    private createDirectory;
+    private canWrite;
+}

package/storage/handler/transfer-content-handler.d.ts

@@ -0,0 +1,51 @@
+import { ExistingContentAction, TransferContentsRequest } from '..';
+import { Content } from '../../content';
+import { EventsBusService } from '../../events-bus';
+import { ContentEntry } from '../../content/db/schema';
+import { FileService } from '../../util/file/def/file-service';
+import { DbService } from '../../db';
+import { SdkConfig } from '../../sdk-config';
+import { DeviceInfo } from '../../util/device';
+import { Observable } from 'rxjs';
+export declare enum MoveContentStatus {
+    SAME_VERSION_IN_BOTH = "SAME_VERSION_IN_BOTH",
+    HIGHER_VERSION_IN_DESTINATION = "HIGHER_VERSION_IN_DESTINATION",
+    LOWER_VERSION_IN_DESTINATION = "LOWER_VERSION_IN_DESTINATION"
+}
+export interface MoveContentResponse {
+    identifier: string;
+    status: MoveContentStatus;
+}
+export interface TransferContentContext {
+    contentIds?: string[];
+    validContentIdsInDestination?: string[];
+    destinationFolder?: string;
+    sourceFolder?: string;
+    contentsInSource?: ContentEntry.SchemaMap[];
+    contentsInDestination?: Content[];
+    existingContentAction?: ExistingContentAction;
+    duplicateContents?: MoveContentResponse[];
+    deleteDestination?: boolean;
+    hasTransferCancelled?: boolean;
+    shouldMergeInDestination?: boolean;
+}
+export interface Manifest {
+    version: string;
+    archive: {
+        items: {
+            status: string;
+            expires: string;
+        }[];
+    };
+}
+export declare class TransferContentHandler {
+    private sdkConfig;
+    private fileService;
+    private dbService;
+    private eventsBusService;
+    private deviceInfo;
+    private readonly context;
+    constructor(sdkConfig: SdkConfig, fileService: FileService, dbService: DbService, eventsBusService: EventsBusService, deviceInfo: DeviceInfo);
+    transfer({ contentIds, existingContentAction, deleteDestination, destinationFolder, shouldMergeInDestination, sourceFolder }: TransferContentsRequest): Observable<undefined>;
+    cancel(): Observable<undefined>;
+}

package/storage/impl/storage-service-impl.d.ts

@@ -0,0 +1,35 @@
+import { StorageDestination, StorageService, TransferContentsRequest } from '..';
+import { Observable } from 'rxjs';
+import { Content } from '../../content';
+import { EventsBusService } from '../../events-bus';
+import { SharedPreferences } from '../../util/shared-preferences';
+import { DbService } from '../../db';
+import { DeviceInfo, StorageVolume } from '../../util/device';
+import { SdkConfig } from '../../sdk-config';
+import { FileService } from '../../util/file/def/file-service';
+export declare class StorageServiceImpl implements StorageService {
+    private eventsBusService;
+    private sharedPreferences;
+    private dbService;
+    private deviceInfo;
+    private fileService;
+    private sdkConfig;
+    private static readonly STORAGE_DESTINATION;
+    private contentsToTransfer;
+    private transferContentHandler;
+    private lastTransferContentsRequest?;
+    private currentStorageDestination;
+    private availableStorageVolumes;
+    constructor(eventsBusService: EventsBusService, sharedPreferences: SharedPreferences, dbService: DbService, deviceInfo: DeviceInfo, fileService: FileService, sdkConfig: SdkConfig);
+    onInit(): Observable<undefined>;
+    getStorageDestinationDirectoryPath(): string | undefined;
+    cancelTransfer(): Observable<undefined>;
+    getStorageDestination(): Observable<StorageDestination>;
+    getStorageDestinationVolumeInfo(): Observable<StorageVolume>;
+    getToTransferContents(): Observable<Content[]>;
+    getTransferringContent(): Observable<Content | undefined>;
+    retryCurrentTransfer(): Observable<undefined>;
+    transferContents(transferContentsRequest: TransferContentsRequest): Observable<undefined>;
+    scanStorage(): Observable<boolean>;
+    private resetStorageDestination;
+}

package/storage/index.d.ts

@@ -0,0 +1,6 @@
+export * from './def/storage-destination';
+export * from './def/storage-service';
+export * from './def/storage-event';
+export * from './def/storage-requests';
+export * from './errors/transfer-failed-duplicate-content-error';
+export * from './errors/transfer-failed-error';

package/summarizer/assesment-analyzer.d.ts

@@ -0,0 +1,4 @@
+import { SummarizerService } from '..';
+export declare class AssesmentAnalyzer {
+    static readonly analyze: SummarizerService;
+}

package/summarizer/db/schema.d.ts

@@ -0,0 +1,21 @@
+export declare namespace CourseAssessmentEntry {
+    const TABLE_NAME = "course_assessment";
+    const _ID = "_id";
+    const COLUMN_NAME_ASSESSMENT_EVENT = "assessment_event";
+    const COLUMN_NAME_CREATED_AT = "created_at";
+    const COLUMN_NAME_USER_ID = "user_id";
+    const COLUMN_NAME_CONTENT_ID = "content_id";
+    const COLUMN_NAME_COURSE_ID = "course_id";
+    const COLUMN_NAME_BATCH_ID = "batch_id";
+    interface SchemaMap {
+        [_ID]: number;
+        [COLUMN_NAME_ASSESSMENT_EVENT]: string;
+        [COLUMN_NAME_CREATED_AT]: number;
+        [COLUMN_NAME_USER_ID]: string;
+        [COLUMN_NAME_CONTENT_ID]: string;
+        [COLUMN_NAME_COURSE_ID]: string;
+        [COLUMN_NAME_BATCH_ID]: string;
+    }
+    const getCreateEntry: (() => string);
+    const deleteTable: (() => string);
+}

package/summarizer/def/request.d.ts

@@ -0,0 +1,6 @@
+export interface SummaryRequest {
+    qId: string;
+    uids: string[];
+    contentId: string;
+    hierarchyData: string;
+}

package/summarizer/def/response.d.ts

@@ -0,0 +1,77 @@
+export interface LearnerAssessmentSummary {
+    uid: string;
+    contentId: string;
+    noOfQuestions: number;
+    correctAnswers: number;
+    totalTimespent: number;
+    hierarchyData: string;
+    totalQuestionsScore: number;
+    totalMaxScore: number;
+    totalScore: number;
+    name?: string;
+    lastUsedTime?: number;
+}
+export interface LearnerAssessmentDetails {
+    id?: number;
+    uid: string;
+    contentId: string;
+    qid: string;
+    qindex: number;
+    correct: number;
+    score: number;
+    timespent: number;
+    res: string;
+    timestamp: number;
+    qdesc: string;
+    qtitle: string;
+    maxScore: number;
+    hierarchyData: string;
+    total_ts?: number;
+    marks?: number;
+    occurenceCount?: number;
+    sum_max_score?: number;
+    correct_users_count?: number;
+}
+export interface LearnerContentSummaryDetails {
+    uid: string;
+    contentId: string;
+    avgts?: number;
+    sessions?: number;
+    totalts?: number;
+    lastUpdated?: number;
+    timespent: number;
+    timestamp: number;
+    ver?: string;
+    hierarchyData: string;
+}
+export interface QuestionSummary {
+    uid: string;
+    time: number;
+    result: number;
+    max_score: number;
+}
+export interface UserReportSummary {
+    totalTimespent: number;
+    score: number;
+    hData: string;
+    contentId: string;
+    uid: string;
+    userName: string;
+    timespent: number;
+}
+export declare class ContentCache {
+    lastUsedTime: number;
+    name: string;
+    identifier: string;
+    totalScore: number;
+}
+export declare class ReportDetailPerUser {
+    uid: string;
+    name: string;
+    totalTime: number;
+    totalScore: number;
+    maxTotalScore: number;
+    totalMaxScore: number;
+    totalQuestionsScore: number;
+    reportDetailsList: LearnerAssessmentDetails[];
+}