@aastrika_npmjs/sunbird-sdk 5.1.1

package/content/util/content-constants.d.ts

@@ -0,0 +1,93 @@
+export declare enum SearchType {
+    SEARCH = "search",
+    FILTER = "filter"
+}
+export declare enum ChildContents {
+    ALL = 0,
+    DOWNLOADED = 1,
+    SPINE = 2
+}
+export declare enum State {
+    SEEN_BUT_NOT_AVAILABLE = 0,
+    ONLY_SPINE = 1,
+    ARTIFACT_AVAILABLE = 2
+}
+export declare enum MimeType {
+    APK = "application/vnd.android.package-archive",
+    ECML = "application/vnd.ekstep.ecml-archive",
+    HTML = "application/vnd.ekstep.html-archive",
+    COLLECTION = "application/vnd.ekstep.content-collection",
+    H5P = "application/vnd.ekstep.h5p-archive",
+    VIDEO = "video/mp4",
+    YOUTUBE = "video/x-youtube",
+    WEBM = "video/webm",
+    QUESTION = "application/vnd.sunbird.question",
+    QUESTION_SET = "application/vnd.sunbird.questionset",
+    EPUB = "application/epub",
+    ZIP = "application/zip",
+    TXT = "text/plain",
+    ECAR = "application/ecar",
+    EPAR = "application/epar"
+}
+export declare enum Visibility {
+    DEFAULT = "Default",
+    PARENT = "Parent"
+}
+export declare enum ContentStatus {
+    LIVE = "Live",
+    DRAFT = "Draft"
+}
+export declare enum ContentEncoding {
+    GZIP = "gzip",
+    IDENTITY = "identity"
+}
+export declare enum ContentDisposition {
+    ATTACHMENT = "attachment",
+    INLINE = "inline",
+    ONLINE = "online"
+}
+export declare enum FileExtension {
+    CONTENT = "ecar",
+    PROFILE = "epar",
+    TELEMETRY = "gsa"
+}
+export declare enum ContentImportStatus {
+    NOT_FOUND = -1,
+    ENQUEUED_FOR_DOWNLOAD = 0,
+    DOWNLOAD_STARTED = 1,
+    DOWNLOAD_FAILED = 2,
+    DOWNLOAD_COMPLETED = 3,
+    IMPORT_STARTED = 4,
+    IMPORT_FAILED = 5,
+    NOT_COMPATIBLE = 6,
+    CONTENT_EXPIRED = 7,
+    ALREADY_EXIST = 8,
+    IMPORT_COMPLETED = 100
+}
+export declare enum ContentErrorCode {
+    NO_DATA_FOUND = "NO_DATA_FOUND",
+    INVALID_FILE = "INVALID_FILE",
+    ECAR_NOT_FOUND = "ECAR_NOT_FOUND",
+    IMPORT_FAILED_DEVICE_MEMORY_FULL = "IMPORT_FAILED_DEVICE_MEMORY_FULL",
+    IMPORT_FAILED_EXTRACT_ECAR = "IMPORT_FAILED_EXTRACTION",
+    IMPORT_FAILED_MANIFEST_FILE_NOT_FOUND = "IMPORT_FAILED_MANIFEST_FILE_NOT_FOUND",
+    IMPORT_FAILED_UNSUPPORTED_MANIFEST = "IMPORT_FAILED_UNSUPPORTED_MANIFEST",
+    IMPORT_FAILED_NO_CONTENT_METADATA = "IMPORT_FAILED_NO_CONTENT_METADATA",
+    DUPLICATE_CONTENT = "DUPLICATE_CONTENT",
+    IMPORT_FILE_EXIST = "IMPORT_FILE_EXIST",
+    ECAR_CLEANUP_FAILED = "ECAR_CLEANUP_FAILED",
+    EXPORT_FAILED_COPY_ASSET = "EXPORT_FAILED_COPY_ASSET",
+    EXPORT_FAILED_MEMORY_NOT_SUFFICIENT = "EXPORT_FAILED_MEMORY_NOT_SUFFICIENT",
+    EXPORT_FAILED_WRITING_MANIFEST = "EXPORT_FAILED_WRITE_MANIFEST",
+    EXPORT_FAILED_ECAR_BUNDLE = "EXPORT_FAILED_ECAR_BUNDLE",
+    EXPORT_FAILED_NOTHING_TO_EXPORT = "EXPORT_FAILED_NOTHING_TO_EXPORT",
+    EXPORT_FAILED_DELETING_ECAR = "EXPORT_FAILED_DELETING_ECAR"
+}
+export declare enum ErrorCode {
+    EXPORT_FAILED = "EXPORT_FAILED",
+    IMPORT_FAILED = "IMPORT_FAILED"
+}
+export declare enum FileName {
+    MANIFEST = "manifest.json",
+    HIERARCHY = "hierarchy.json"
+}

package/content/util/content-mapper.d.ts

@@ -0,0 +1,7 @@
+import { ContentEntry } from '../db/schema';
+import { Content } from '..';
+export declare class ContentMapper {
+    static mapContentDataToContentDBEntry(contentData: any, manifestVersion: string): ContentEntry.SchemaMap;
+    static mapServerResponseToContent(contentData: any, manifestVersion?: string): Content;
+    static mapContentDBEntryToContent(contentEntry: ContentEntry.SchemaMap, shouldConvertBasePath?: boolean): Content;
+}

package/content/util/content-util.d.ts

@@ -0,0 +1,94 @@
+import { ContentData, HierarchyInfo } from '../def/content';
+import { Rollup } from '../../telemetry';
+import { AppConfig } from '../../api/config/app-config';
+import { ContentEntry } from '../db/schema';
+export declare class ContentUtil {
+    static defaultCompatibilityLevel: number;
+    private static DEFAULT_PACKAGE_VERSION;
+    private static INITIAL_VALUE_FOR_TRANSFER_COUNT;
+    private static readonly MAX_CONTENT_NAME;
+    static isAvailableLocally(contentState: number): boolean;
+    static isUpdateAvailable(serverData: ContentData, localData: ContentData): boolean;
+    static hasChildren(localData: any): boolean;
+    static getContentRollup(identifier: string, hierarchyInfoList: HierarchyInfo[]): Rollup;
+    static getChildContentsIdentifiers(localData: any): string[];
+    /**
+     * This method gets you the first part of the string that is divided after last index of "/"
+     *
+     * @param contentFolderName
+     * @return
+     */
+    static getFirstPartOfThePathNameOnLastDelimiter(contentFolderName: string): string | undefined;
+    static hasPreRequisites(localData: string): boolean;
+    static readVisibility(contentData: any): string;
+    static isCompatible(appConfig: AppConfig, compatibilityLevel: any): boolean;
+    static readCompatibilityLevel(contentData: any): number;
+    static isDraftContent(status: any): boolean;
+    static isExpired(expiryDate: string): boolean;
+    /**
+     * If status is DRAFT and pkgVersion == 0 then don't do the duplicate check..
+     */
+    static isDuplicateCheckRequired(isDraftContent: any, pkgVersion: number): boolean;
+    static isImportFileExist(oldContentModel: ContentEntry.SchemaMap | undefined, contentData: any): boolean;
+    static readPkgVersion(contentData: any): number;
+    static readContentType(contentData: any): string;
+    static readPrimaryCategory(contentData: any): string;
+    static readPrimaryCategoryServer(contentData: any): string;
+    static readAudience(contentData: any): string;
+    static readPragma(contentData: any): string;
+    /**
+     * To Check whether the content is exist or not.
+     *
+     * @param existingContentInDB    Old ContentModel
+     * @param newIdentifier New content identifier
+     * @param newPkgVersion
+     * @param keepLowerVersion
+     * @return True - if file exists, False- does not exists
+     */
+    static doesContentExist(existingContentInDB: ContentEntry.SchemaMap | undefined, newIdentifier: string, newPkgVersion: number, keepLowerVersion: boolean): boolean;
+    static getContentRootDir(rootFilePath: string): string;
+    static addOrUpdateViralityMetadata(localData: any, origin: string): void;
+    static addViralityMetadataIfMissing(localData: any, origin: string): void;
+    /**
+     * Content with artifact without zip i.e. pfd, mp4
+     *
+     * @param contentDisposition
+     * @param contentEncoding
+     * @return
+     */
+    static isInlineIdentity(contentDisposition: string, contentEncoding: string): boolean | "";
+    static isOnlineContent(contentData: any): boolean;
+    static addOrUpdateDialcodeMapping(jsonStr: string, identifier: string, rootNodeIdentifier: string): string;
+    static deDupe<T>(array: T[], property: any): T[];
+    static getExportedFileName(contentsInDb: ContentEntry.SchemaMap[], appName: string): string;
+    static readOriginFromContentMap(item: any): string;
+    static readTransferCountFromContentMap(item: any): number;
+    static readSizeFromContentMap(item: any): string;
+    static getUidnIdentifierFiler(uid: string, identifier: any): string;
+    static getBasePath(basePath: string): string;
+    static getRollup(identifier: string, hierachyInfo: HierarchyInfo[]): Rollup;
+    static addOrUpdateRefCount(refCount: number): number;
+    static isNotUnit(mimeType: any, visibility: any): boolean;
+    static getContentAttribute(data: any): string;
+    static getFindAllContentsWithIdentifierQuery(identifiers: string[]): string;
+    static getFindAllContentsQuery(): string;
+    static constructContentDBModel(identifier: any, manifestVersion: any, localData: any, mimeType: any, contentType: any, visibility: any, path: any, refCount: any, contentState: any, audience: any, pragma: any, sizeOnDevice: any, board: any, medium: any, grade: any, primaryCategory: any): ContentEntry.SchemaMap;
+    static getReferenceCount(existingContent: any, visibility: string): number;
+    /**
+     * add or update the reference count for the content
+     *
+     */
+    static getContentVisibility(existingContentInDb: any, objectType: any, previuosVisibility: string): string;
+    /**
+     * Add or update the content_state. contentState should not update the spine_only when importing the spine content
+     * after importing content with artifacts.
+     *
+     */
+    static getContentState(existingContentInDb: any, contentState: number): number;
+    static isFreeSpaceAvailable(deviceAvailableFreeSpace: number, fileSpace: number, bufferSize: number): boolean;
+    private static transferCount;
+    private static isContentMetadataAbsent;
+    private static isContentMetadataPresentWithoutViralityMetadata;
+    static isTrackable(content: any): number;
+    static getParseErrorObject(data: any): any;
+}

package/content/util/linked-list.d.ts

@@ -0,0 +1,16 @@
+export declare class LinkedNode<T> {
+    next: LinkedNode<T> | null;
+    private readonly _elem;
+    constructor(elem: T);
+    readonly elem: T;
+}
+export declare class LinkedList<T> {
+    private head;
+    private len;
+    constructor(headElement?: LinkedNode<T>);
+    append(elem: T): void;
+    isEmpty(): number;
+    addAll(list: T[]): void;
+    remove(): LinkedNode<T> | undefined;
+    private removeAt;
+}

package/content/util/stack.d.ts

@@ -0,0 +1,10 @@
+export declare class Stack<T> {
+    private _stack;
+    constructor(stack?: T[]);
+    readonly count: number;
+    push(item: T): void;
+    pop(): T;
+    clear(): void;
+    isEmpty(): boolean;
+    addAll(item: T[]): void;
+}

package/course/config/course-service-config.d.ts

@@ -0,0 +1,3 @@
+export interface CourseServiceConfig {
+    apiPath: string;
+}

package/course/course-util.d.ts

@@ -0,0 +1,6 @@
+import { UpdateContentStateAPIRequest, UpdateContentStateRequest } from './def/request-types';
+export declare class CourseUtil {
+    static getUpdateContentStateRequest(updateContentReq: UpdateContentStateRequest): UpdateContentStateAPIRequest;
+    static getUpdateContentStateListRequest(userId: string, updateContentReqList: UpdateContentStateRequest[]): UpdateContentStateAPIRequest;
+    private static getRequestMap;
+}

package/course/def/batch.d.ts

@@ -0,0 +1 @@
+export { Batch } from '@project-sunbird/client-services/models';

package/course/def/course-batches-response.d.ts

@@ -0,0 +1,5 @@
+import { Batch } from './batch';
+export declare class CourseBatchesResponse {
+    count: number;
+    content: Batch[];
+}

package/course/def/course-certificate-manager.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import { DownloadCertificateRequest } from './download-certificate-request';
+import { DownloadCertificateResponse } from './download-certificate-response';
+import { GetCertificateRequest } from './get-certificate-request';
+export interface CourseCertificateManager {
+    isCertificateCached(request: GetCertificateRequest): Observable<boolean>;
+    getCertificate(request: GetCertificateRequest): Observable<string>;
+    downloadCertificate(downloadCertificateRequest: DownloadCertificateRequest): Observable<DownloadCertificateResponse>;
+}

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

@@ -0,0 +1,51 @@
+import { ContentStateResponse, CourseBatchDetailsRequest, CourseBatchesRequest, DisplayDiscussionForumRequest, EnrollCourseRequest, FetchEnrolledCourseRequest, GenerateAttemptIdRequest, GetContentStateRequest, GetLearnerCerificateRequest, GetUserEnrolledCoursesRequest, UpdateContentStateRequest } from './request-types';
+import { Observable } from 'rxjs';
+import { Batch } from './batch';
+import { Course } from './course';
+import { UnenrollCourseRequest } from './unenrollCourseRequest';
+import { GetCertificateRequest } from './get-certificate-request';
+import { DownloadCertificateResponse } from './download-certificate-response';
+import { SunbirdTelemetry } from '../../telemetry';
+import Telemetry = SunbirdTelemetry.Telemetry;
+import { LearnerCertificate } from './get-learner-certificate-response';
+import { ApiRequestHandler } from '../../api';
+import { GetEnrolledCourseResponse } from './get-enrolled-course-response';
+import { CourseCertificateManager } from './course-certificate-manager';
+import { UpdateContentStateResponse } from './update-content-state-response';
+import { UpdateCourseContentStateRequest } from './update-course-content-state-request';
+export interface CourseService {
+    certificateManager: CourseCertificateManager;
+    getBatchDetails(request: CourseBatchDetailsRequest): Observable<Batch>;
+    updateContentState(request: UpdateContentStateRequest): Observable<boolean>;
+    getCourseBatches(request: CourseBatchesRequest): Observable<Batch[]>;
+    getEnrolledCourses(request: FetchEnrolledCourseRequest, apiHandler?: ApiRequestHandler<{
+        userId: string;
+    }, GetEnrolledCourseResponse>): Observable<Course[]>;
+    getUserEnrolledCourses(request: GetUserEnrolledCoursesRequest): Observable<Course[]>;
+    enrollCourse(request: EnrollCourseRequest): Observable<boolean>;
+    unenrollCourse(unenrollCourseRequest: UnenrollCourseRequest): Observable<boolean>;
+    getContentState(contentStateRequest: GetContentStateRequest): Observable<ContentStateResponse | undefined>;
+    downloadCurrentProfileCourseCertificate(downloadCertificateRequest: GetCertificateRequest): Observable<DownloadCertificateResponse>;
+    /** @internal */
+    hasCapturedAssessmentEvent(request: {
+        courseContext: any;
+    }): boolean;
+    /** @internal */
+    captureAssessmentEvent(capture: {
+        event: Telemetry;
+        courseContext: any;
+    }): any;
+    /** @internal */
+    resetCapturedAssessmentEvents(): any;
+    syncAssessmentEvents(options?: {
+        persistedOnly: boolean;
+    }): Observable<undefined>;
+    generateAssessmentAttemptId(request: GenerateAttemptIdRequest): string;
+    displayDiscussionForum(request: DisplayDiscussionForumRequest): Observable<boolean>;
+    getLearnerCertificates(request: GetLearnerCerificateRequest): Observable<{
+        count: number;
+        content: LearnerCertificate[];
+    }>;
+    syncCourseProgress(request: UpdateCourseContentStateRequest): Observable<UpdateContentStateResponse>;
+    clearAssessments(): Observable<undefined>;
+}

package/course/def/course.d.ts

@@ -0,0 +1 @@
+export { Course, CourseCertificate } from '@project-sunbird/client-services/models';

package/course/def/download-certificate-request.d.ts

@@ -0,0 +1,5 @@
+export interface DownloadCertificateRequest {
+    fileName: string;
+    mimeType: string;
+    blob: Blob;
+}

package/course/def/download-certificate-response.d.ts

@@ -0,0 +1,3 @@
+export interface DownloadCertificateResponse {
+    path: string;
+}

package/course/def/get-certificate-request.d.ts

@@ -0,0 +1,6 @@
+import { CourseCertificate } from './course';
+export { CertificateType } from '@project-sunbird/client-services/services/certificate';
+export interface GetCertificateRequest {
+    courseId: string;
+    certificate: CourseCertificate;
+}

package/course/def/get-enrolled-course-response.d.ts

@@ -0,0 +1,10 @@
+import { Course } from './course';
+export interface GetEnrolledCourseResponse {
+    id: string;
+    params: {
+        resmsgid: string;
+    };
+    result: {
+        courses: Course[];
+    };
+}

package/course/def/get-learner-certificate-response.d.ts

@@ -0,0 +1,22 @@
+export interface LearnerCertificate {
+    _index: string;
+    _type: string;
+    _id: string;
+    _score: number;
+    _source: {
+        pdfUrl: string;
+        data: {
+            badge: {
+                name: string;
+                issuer: {
+                    name: string;
+                };
+            };
+            issuedOn: string;
+        };
+        related: {
+            courseId: string;
+            Id: string;
+        };
+    };
+}

package/course/def/request-types.d.ts

@@ -0,0 +1,83 @@
+import { SortOrder } from '../../content';
+import { GetUserEnrolledCoursesRequest as CsGetUserEnrolledCoursesRequest, GetContentStateRequest as CsGetContentStateRequest, ContentState } from '@project-sunbird/client-services/services/course';
+export { ContentState } from '@project-sunbird/client-services/services/course';
+import { CachedItemRequest, CachedItemRequestSourceFrom } from '../../key-value-store';
+export interface FetchEnrolledCourseRequest {
+    userId: string;
+    returnFreshCourses?: boolean;
+}
+export interface EnrollCourseRequest {
+    userId: string;
+    courseId: string;
+    batchId: string;
+    batchStatus?: number;
+}
+export declare enum UpdateContentStateTarget {
+    LOCAL = "LOCAL",
+    SERVER = "SERVER"
+}
+export interface UpdateContentStateRequest {
+    target?: UpdateContentStateTarget[];
+    userId: string;
+    courseId: string;
+    contentId: string;
+    batchId: string;
+    result?: string;
+    grade?: string;
+    status?: ContentState['status'];
+    progress?: ContentState['progress'];
+    score?: ContentState['score'];
+    bestScore?: ContentState['bestScore'];
+}
+export interface CourseBatchesRequest {
+    filters: CourseBatchesRequestFilters;
+    fields: string[];
+    sort_by?: {
+        [key: string]: SortOrder;
+    };
+}
+export interface UpdateContentStateAPIRequest {
+    userId: string;
+    contents: ContentState[];
+}
+export interface CourseBatchDetailsRequest {
+    batchId: string;
+}
+export interface GetContentStateRequest extends CsGetContentStateRequest {
+    returnRefreshedContentStates?: boolean;
+}
+export interface CourseBatchesRequestFilters {
+    courseId: string[] | string;
+    status?: string[];
+    enrollmentType?: string;
+}
+export declare enum CourseEnrollmentType {
+    OPEN = "open",
+    INVITE_ONLY = "invite-only"
+}
+export declare enum CourseBatchStatus {
+    NOT_STARTED = "0",
+    IN_PROGRESS = "1",
+    COMPLETED = "2"
+}
+export interface ContentStateResponse {
+    contentList: ContentState[];
+}
+export interface GenerateAttemptIdRequest {
+    courseId: string;
+    batchId: string;
+    contentId: string;
+    userId: string;
+    date?: number;
+}
+export interface GetUserEnrolledCoursesRequest {
+    from?: CachedItemRequestSourceFrom;
+    request: CsGetUserEnrolledCoursesRequest;
+}
+export interface DisplayDiscussionForumRequest {
+    forumId: string;
+}
+export interface GetLearnerCerificateRequest extends CachedItemRequest {
+    userId: string;
+    size?: number;
+}

package/course/def/unenrollCourseRequest.d.ts

@@ -0,0 +1,5 @@
+export interface UnenrollCourseRequest {
+    userId: string;
+    courseId: string;
+    batchId: string;
+}

package/course/def/update-content-state-response.d.ts

@@ -0,0 +1 @@
+export { CsUpdateContentStateResponse as UpdateContentStateResponse } from '@project-sunbird/client-services/services/course';

package/course/def/update-course-content-state-request.d.ts

@@ -0,0 +1 @@
+export { CsUpdateContentStateRequest as UpdateCourseContentStateRequest } from '@project-sunbird/client-services/services/course';

package/course/errors/certificate-already-downloaded.d.ts

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

package/course/errors/no-certificate-found.d.ts

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

package/course/handlers/enroll-course-handler.d.ts

@@ -0,0 +1,11 @@
+import { ApiRequestHandler, ApiService } from '../../api';
+import { CourseServiceConfig, EnrollCourseRequest } from '..';
+import { Observable } from 'rxjs';
+export declare class EnrollCourseHandler implements ApiRequestHandler<EnrollCourseRequest, boolean> {
+    private apiService;
+    private courseServiceConfig;
+    private readonly ENROL_ENDPOINT;
+    constructor(apiService: ApiService, courseServiceConfig: CourseServiceConfig);
+    handle(request: EnrollCourseRequest): Observable<boolean>;
+    private generateAuditTelemetry;
+}

package/course/handlers/get-batch-details-handler.d.ts

@@ -0,0 +1,10 @@
+import { ApiRequestHandler, ApiService } from '../../api';
+import { Observable } from 'rxjs';
+import { Batch, CourseBatchDetailsRequest, CourseServiceConfig } from '..';
+export declare class GetBatchDetailsHandler implements ApiRequestHandler<CourseBatchDetailsRequest, Batch> {
+    private apiService;
+    private courseServiceConfig;
+    readonly GET_BATCH_DETAILS_ENDPOINT: string;
+    constructor(apiService: ApiService, courseServiceConfig: CourseServiceConfig);
+    handle(request: CourseBatchDetailsRequest): Observable<Batch>;
+}

package/course/handlers/get-content-state-handler.d.ts

@@ -0,0 +1,16 @@
+import { ApiService } from '../../api';
+import { ContentState, CourseServiceConfig, GetContentStateRequest } from '..';
+import { Observable } from 'rxjs';
+import { Container } from 'inversify';
+export declare class GetContentStateHandler {
+    private apiService;
+    private courseServiceConfig;
+    private container;
+    constructor(apiService: ApiService, courseServiceConfig: CourseServiceConfig, container: Container);
+    private readonly csCourseService;
+    private readonly contentService;
+    handle(contentStateRequest: GetContentStateRequest): Observable<{
+        contentList: ContentState[];
+    }>;
+    private fetchFromApi;
+}

package/course/handlers/get-course-batches-handler.d.ts

@@ -0,0 +1,10 @@
+import { ApiRequestHandler, ApiService } from '../../api';
+import { Batch, CourseBatchesRequest, CourseServiceConfig } from '..';
+import { Observable } from 'rxjs';
+export declare class GetCourseBatchesHandler implements ApiRequestHandler<CourseBatchesRequest, Batch[]> {
+    private apiService;
+    private courseServiceConfig;
+    private readonly GET_COURSE_BATCHES;
+    constructor(apiService: ApiService, courseServiceConfig: CourseServiceConfig);
+    handle(request: CourseBatchesRequest): Observable<Batch[]>;
+}

package/course/handlers/get-enrolled-course-handler.d.ts

@@ -0,0 +1,21 @@
+import { ApiRequestHandler, ApiService } from '../../api';
+import { Course, CourseServiceConfig, FetchEnrolledCourseRequest } from '..';
+import { Observable } from 'rxjs';
+import { KeyValueStore } from '../../key-value-store';
+import { GetEnrolledCourseResponse } from '../def/get-enrolled-course-response';
+import { SharedPreferences } from '../../util/shared-preferences';
+export declare class GetEnrolledCourseHandler implements ApiRequestHandler<FetchEnrolledCourseRequest, Course[]> {
+    private keyValueStore;
+    private apiService;
+    private courseServiceConfig;
+    private sharedPreference;
+    private apiHandler?;
+    private readonly GET_ENROLLED_COURSES_ENDPOINT;
+    private readonly STORED_ENROLLED_COURSES_PREFIX;
+    constructor(keyValueStore: KeyValueStore, apiService: ApiService, courseServiceConfig: CourseServiceConfig, sharedPreference: SharedPreferences, apiHandler?: ApiRequestHandler<{
+        userId: string;
+    }, GetEnrolledCourseResponse> | undefined);
+    handle(request: FetchEnrolledCourseRequest): Observable<Course[]>;
+    private updateLastPlayedContent;
+    private fetchFromServer;
+}

package/course/handlers/get-learner-certificate-handler.d.ts

@@ -0,0 +1,20 @@
+import { ApiRequestHandler, ApiService } from '../../api';
+import { GetLearnerCerificateRequest } from '..';
+import { Observable } from 'rxjs';
+import { LearnerCertificate } from '../def/get-learner-certificate-response';
+import { CachedItemStore } from '../../key-value-store';
+export declare class GetLearnerCertificateHandler implements ApiRequestHandler<GetLearnerCerificateRequest, {
+    count: number;
+    content: LearnerCertificate[];
+}> {
+    private apiService;
+    private cachedItemStore;
+    private static readonly CERTIFICATE_SEARCH_ENDPOINT;
+    private static readonly GET_LEARNER_CERTIFICATE_LOCAL_KEY;
+    constructor(apiService: ApiService, cachedItemStore: CachedItemStore);
+    handle(request: GetLearnerCerificateRequest): Observable<{
+        count: number;
+        content: LearnerCertificate[];
+    }>;
+    private fetchFromServer;
+}

package/course/handlers/offline-content-state-handler.d.ts

@@ -0,0 +1,12 @@
+import { KeyValueStore } from '../../key-value-store';
+import { ContentStateResponse, GetContentStateRequest, UpdateContentStateRequest } from '..';
+import { Observable } from 'rxjs';
+export declare class OfflineContentStateHandler {
+    private keyValueStore;
+    constructor(keyValueStore: KeyValueStore);
+    getLocalContentStateResponse(request: GetContentStateRequest): Observable<ContentStateResponse>;
+    manipulateEnrolledCoursesResponseLocally(updateContentStateRequest: UpdateContentStateRequest): Observable<boolean>;
+    manipulateGetContentStateResponseLocally(updateContentStateRequest: UpdateContentStateRequest): Observable<boolean>;
+    getCourseCompletionPercentage(leafNodeCount: number | undefined, progress: number): number;
+    private getContentState;
+}

package/course/handlers/offline-course-cache-handler.d.ts

@@ -0,0 +1,15 @@
+import { DbService } from '../../db';
+import { Course, EnrollCourseRequest } from '..';
+import { ContentService } from '../../content';
+import { Observable } from 'rxjs';
+import { KeyValueStore } from '../../key-value-store';
+export declare class OfflineCourseCacheHandler {
+    private dbService;
+    private contentService;
+    private keyValueStore;
+    private static readonly GET_ENROLLED_COURSES_KEY_PREFIX;
+    constructor(dbService: DbService, contentService: ContentService, keyValueStore: KeyValueStore);
+    addNewlyEnrolledCourseToGetEnrolledCourses(enrollCourseRequest: EnrollCourseRequest): Observable<boolean>;
+    getNewlyAddedCourse(enrollCourseRequest: EnrollCourseRequest): Observable<Course>;
+    private getLeafNodeCount;
+}

package/course/handlers/sync-assessment-events-handler.d.ts

@@ -0,0 +1,22 @@
+import { Observable } from 'rxjs';
+import { SunbirdTelemetry } from '../../telemetry';
+import { DbService } from '../../db';
+import { SdkConfig } from '../../sdk-config';
+import { CourseService } from '..';
+import { NetworkQueue } from '../../api/network-queue';
+export declare class SyncAssessmentEventsHandler {
+    private courseService;
+    private sdkConfig;
+    private dbService;
+    private networkQueue;
+    private static readonly UPDATE_CONTENT_STATE_ENDPOINT;
+    private capturedAssessmentEvents;
+    constructor(courseService: CourseService, sdkConfig: SdkConfig, dbService: DbService, networkQueue: NetworkQueue);
+    handle(capturedAssessmentEvents: {
+        [key: string]: SunbirdTelemetry.Telemetry[] | undefined;
+    }): Observable<undefined>;
+    private invokeSyncApi;
+    private persistAssessEvent;
+    private syncCapturedAssessmentEvents;
+    private syncPersistedAssessmentEvents;
+}

package/course/handlers/unenroll-course-handler.d.ts

@@ -0,0 +1,10 @@
+import { ApiRequestHandler, ApiService } from '../../api';
+import { CourseServiceConfig, UnenrollCourseRequest } from '..';
+import { Observable } from 'rxjs';
+export declare class UnenrollCourseHandler implements ApiRequestHandler<UnenrollCourseRequest, boolean> {
+    private apiService;
+    private unenrollCourseServiceApiConfig;
+    private readonly GET_UNENROLL_COURSE_ENDPOINT;
+    constructor(apiService: ApiService, unenrollCourseServiceApiConfig: CourseServiceConfig);
+    handle(unenrollCourseRequest: UnenrollCourseRequest): Observable<boolean>;
+}