@aastrika_npmjs/sunbird-sdk 5.1.1

package/content/handlers/export/compress-content.d.ts

@@ -0,0 +1,8 @@
+import { ZipService } from '../../../util/zip/def/zip-service';
+import { ExportContentContext } from '../..';
+import { Response } from '../../../api';
+export declare class CompressContent {
+    private zipService;
+    constructor(zipService: ZipService);
+    execute(exportContentContext: ExportContentContext): Promise<Response>;
+}

package/content/handlers/export/copy-asset.d.ts

@@ -0,0 +1,8 @@
+import { ExportContentContext } from '../..';
+import { Response } from '../../../api';
+export declare class CopyAsset {
+    constructor();
+    execute(exportContentContext: ExportContentContext): Promise<Response>;
+    private excludeContentForSubModule;
+    private copyFile;
+}

package/content/handlers/export/copy-to-destination.d.ts

@@ -0,0 +1,6 @@
+import { Response } from '../../../api';
+import { ContentExportRequest } from '../..';
+export declare class CopyToDestination {
+    constructor();
+    execute(exportResponse: Response, contentExportRequest: ContentExportRequest): Promise<Response>;
+}

package/content/handlers/export/create-content-export-manifest.d.ts

@@ -0,0 +1,12 @@
+import { DbService } from '../../../db';
+import { ExportContentContext } from '../..';
+import { Response } from '../../../api';
+import { ImportNExportHandler } from '../import-n-export-handler';
+export declare class CreateContentExportManifest {
+    private dbService;
+    private exportHandler;
+    private static readonly EKSTEP_CONTENT_ARCHIVE;
+    private static readonly SUPPORTED_MANIFEST_VERSION;
+    constructor(dbService: DbService, exportHandler: ImportNExportHandler);
+    execute(exportContentContext: ExportContentContext): Promise<Response>;
+}

package/content/handlers/export/create-temp-loc.d.ts

@@ -0,0 +1,8 @@
+import { FileService } from '../../../util/file/def/file-service';
+import { ExportContentContext } from '../..';
+import { Response } from '../../../api';
+export declare class CreateTempLoc {
+    private fileService;
+    constructor(fileService: FileService);
+    execute(exportContext: ExportContentContext): Promise<Response>;
+}

package/content/handlers/export/delete-temp-ecar.d.ts

@@ -0,0 +1,8 @@
+import { FileService } from '../../../util/file/def/file-service';
+import { ExportContentContext } from '../..';
+import { Response } from '../../../api';
+export declare class DeleteTempEcar {
+    private fileService;
+    constructor(fileService: FileService);
+    execute(exportContentContext: ExportContentContext): Promise<Response>;
+}

package/content/handlers/export/deletete-temp-dir.d.ts

@@ -0,0 +1,6 @@
+import { Response } from '../../../api';
+import { ExportContentContext } from '../..';
+export declare class DeleteTempDir {
+    constructor();
+    execute(exportContext: ExportContentContext): Promise<Response>;
+}

package/content/handlers/export/device-memory-check.d.ts

@@ -0,0 +1,9 @@
+import { FileService } from '../../../util/file/def/file-service';
+import { ExportContentContext } from '../..';
+import { Response } from '../../../api';
+export declare class DeviceMemoryCheck {
+    private fileService;
+    constructor(fileService: FileService);
+    execute(exportContentContext: ExportContentContext): Promise<Response>;
+    private getFileSize;
+}

package/content/handlers/export/ecar-bundle.d.ts

@@ -0,0 +1,11 @@
+import { FileService } from '../../../util/file/def/file-service';
+import { ZipService } from '../../../util/zip/def/zip-service';
+import { ExportContentContext } from '../..';
+import { Response } from '../../../api';
+export declare class EcarBundle {
+    private fileService;
+    private zipService;
+    private static readonly FILE_SIZE;
+    constructor(fileService: FileService, zipService: ZipService);
+    execute(exportContentContext: ExportContentContext): Promise<Response>;
+}

package/content/handlers/export/generate-export-share-telemetry.d.ts

@@ -0,0 +1,8 @@
+import { ExportContentContext, ContentExportRequest } from '../..';
+import { Response } from '../../../api';
+import { TelemetryService } from '../../../telemetry';
+export declare class GenerateExportShareTelemetry {
+    private telemetryService;
+    constructor(telemetryService: TelemetryService);
+    execute(exportContentContext: ExportContentContext, fileName: string, contentExportRequest: ContentExportRequest): Promise<Response>;
+}

package/content/handlers/export/write-manifest.d.ts

@@ -0,0 +1,10 @@
+import { FileService } from '../../../util/file/def/file-service';
+import { Response } from '../../../api';
+import { ExportContentContext } from '../..';
+import { DeviceInfo } from '../../../util/device';
+export declare class WriteManifest {
+    private fileService;
+    private deviceInfo;
+    constructor(fileService: FileService, deviceInfo: DeviceInfo);
+    execute(exportContentContext: ExportContentContext): Promise<Response>;
+}

package/content/handlers/get-child-contents-handler.d.ts

@@ -0,0 +1,21 @@
+import { Content, HierarchyInfo } from '../def/content';
+import { DbService } from '../../db';
+import { ContentEntry } from '../db/schema';
+import { GetContentDetailsHandler } from './get-content-details-handler';
+import { FileService } from '../../util/file/def/file-service';
+import { AppConfig } from '../../api/config/app-config';
+export declare class ChildContentsHandler {
+    private dbService;
+    private getContentDetailsHandler;
+    private appConfig;
+    private fileService?;
+    constructor(dbService: DbService, getContentDetailsHandler: GetContentDetailsHandler, appConfig: AppConfig, fileService?: FileService | undefined);
+    fetchChildrenOfContent(contentInDb: ContentEntry.SchemaMap, childContentsMap: any, currentLevel: number, level: number, sourceInfoList?: HierarchyInfo[]): Promise<Content>;
+    getContentsKeyList(contentInDb: ContentEntry.SchemaMap): Promise<string[]>;
+    getContentFromDB(hierarchyInfoList: HierarchyInfo[], identifier: string, shouldConvertBasePath?: boolean): Promise<Content>;
+    getNextContentIdentifier(hierarchyInfoList: HierarchyInfo[], currentIdentifier: string, contentKeyList: string[]): string;
+    getPreviousContentIdentifier(hierarchyInfoList: HierarchyInfo[], currentIdentifier: string, contentKeyList: string[]): string;
+    private getSortedChildrenListOld;
+    private getSortedChildrenList;
+    getChildIdentifiersFromManifest(path: string): Promise<string[]>;
+}

package/content/handlers/get-child-question-set-handler.d.ts

@@ -0,0 +1,16 @@
+import { StorageService } from '../../storage/def/storage-service';
+import { FileService } from '../../util/file/def/file-service';
+import { DbService } from '../../db';
+import { ContentServiceImpl } from '../impl/content-service-impl';
+export declare class GetChildQuestionSetHandler {
+    private contentService;
+    private dbService;
+    private storageService;
+    private fileService;
+    constructor(contentService: ContentServiceImpl, dbService: DbService, storageService: StorageService, fileService: FileService);
+    handle(questionSetId: any): Promise<any>;
+    fetchDBChildQuestions(questionSet: any, path: any): Promise<any>;
+    getQuery(questionSetId: any): string;
+    getQuestionSetFromQuery(query: any): Promise<any>;
+    fetchServerChildQuestions(questionSetId: any): Promise<any>;
+}

package/content/handlers/get-content-details-handler.d.ts

@@ -0,0 +1,30 @@
+import { ApiRequestHandler, ApiService } from '../../api';
+import { Content, ContentData, ContentDecorateRequest, ContentDetailRequest, ContentFeedbackService, ContentServiceConfig } from '..';
+import { Observable } from 'rxjs';
+import { DbService, ReadQuery } from '../../db';
+import { ContentEntry } from '../db/schema';
+import { ProfileService } from '../../profile';
+import { EventsBusService } from '../../events-bus';
+export declare class GetContentDetailsHandler implements ApiRequestHandler<ContentDetailRequest, Content> {
+    private contentFeedbackService;
+    private profileService;
+    private apiService;
+    private contentServiceConfig;
+    private dbService;
+    private eventsBusService;
+    private readonly GET_CONTENT_DETAILS_ENDPOINT;
+    constructor(contentFeedbackService: ContentFeedbackService, profileService: ProfileService, apiService: ApiService, contentServiceConfig: ContentServiceConfig, dbService: DbService, eventsBusService: EventsBusService);
+    static getReadContentQuery(identifier: string): ReadQuery;
+    static isUnit(contentDbEntry: ContentEntry.SchemaMap): boolean;
+    handle(request: ContentDetailRequest): Observable<Content>;
+    /** @internal */
+    fetchFromDB(contentId: string): Observable<ContentEntry.SchemaMap | undefined>;
+    fetchFromDBForAll(contentIds: string): Observable<ContentEntry.SchemaMap[]>;
+    fetchFromServer(request: ContentDetailRequest): Observable<ContentData>;
+    fetchAndDecorate(request: ContentDetailRequest): Observable<Content>;
+    /** @internal */
+    decorateContent(request: ContentDecorateRequest): Observable<Content>;
+    private attachContentAccess;
+    private attachFeedback;
+    private attachContentMarker;
+}

package/content/handlers/get-content-heirarchy-handler.d.ts

@@ -0,0 +1,10 @@
+import { ApiRequestHandler, ApiService } from '../../api';
+import { Content, ContentDetailRequest, ContentServiceConfig } from '..';
+export declare class GetContentHeirarchyHandler implements ApiRequestHandler<ContentDetailRequest, Content> {
+    private apiService;
+    private contentServiceConfig;
+    private readonly GET_CONTENT_HEIRARCHY_ENDPOINT;
+    constructor(apiService: ApiService, contentServiceConfig: ContentServiceConfig);
+    handle(request: ContentDetailRequest): import("../../../node_modules/rxjs/internal/Observable").Observable<any>;
+    private mapContentFromContentHeirarchyData;
+}

package/content/handlers/get-contents-handler.d.ts

@@ -0,0 +1,12 @@
+import { ContentRequest } from '..';
+export declare class GetContentsHandler {
+    getAllLocalContentQuery(request: ContentRequest): string;
+    private getAudienceFilter;
+    private getPragmaFilter;
+    private getRecentlyViewedQuery;
+    private getLocalOnlyQuery;
+    private generateSortByQuery;
+    private generateOrderByQuery;
+    private generateFieldMatchQuery;
+    private generateLikeQuery;
+}

package/content/handlers/import/content-search-api-handler.d.ts

@@ -0,0 +1,13 @@
+import { ApiRequestHandler, ApiService } from '../../../api';
+import { ContentServiceConfig, SearchResponse } from '../..';
+import { Observable } from 'rxjs';
+import { SearchRequest } from '../../def/search-request';
+export declare class ContentSearchApiHandler implements ApiRequestHandler<SearchRequest, SearchResponse> {
+    private apiService;
+    private contentServiceConfig;
+    private framework?;
+    private langCode?;
+    private readonly SEARCH_ENDPOINT;
+    constructor(apiService: ApiService, contentServiceConfig: ContentServiceConfig, framework?: string | undefined, langCode?: string | undefined);
+    handle(request: SearchRequest): Observable<SearchResponse>;
+}

package/content/handlers/import/create-content-import-manifest.d.ts

@@ -0,0 +1,15 @@
+import { DbService } from '../../../db';
+import { ImportContentContext } from '../..';
+import { DeviceInfo } from '../../../util/device';
+import { FileService } from '../../../util/file/def/file-service';
+import { Response } from '../../../api';
+export declare class CreateContentImportManifest {
+    private dbService;
+    private deviceInfo;
+    private fileService;
+    private contentDataMap;
+    constructor(dbService: DbService, deviceInfo: DeviceInfo, fileService: FileService);
+    execute(importContentContext: ImportContentContext): Promise<Response>;
+    private createnWriteManifest;
+    private writeFile;
+}

package/content/handlers/import/create-hierarchy.d.ts

@@ -0,0 +1,18 @@
+import { FileService } from '../../../util/file/def/file-service';
+import { ImportContentContext } from '../..';
+import { Response } from '../../../api';
+import { DbService } from '../../../db';
+export declare class CreateHierarchy {
+    private dbService;
+    private fileService;
+    private readonly HIERARCHY_FILE_NAME;
+    private contentMap;
+    constructor(dbService: DbService, fileService: FileService);
+    execute(importContentContext: ImportContentContext): Promise<Response>;
+    /**
+     * fetchChildrenOfContent()
+     * @param content
+     */
+    private createTextBookHierarchy;
+    private getSortedChildrenList;
+}

package/content/handlers/import/device-memory-check.d.ts

@@ -0,0 +1,10 @@
+import { FileService } from '../../../util/file/def/file-service';
+import { ImportContentContext } from '../..';
+import { Response } from '../../../api';
+export declare class DeviceMemoryCheck {
+    private fileService;
+    freeDiskSpace: number;
+    constructor(fileService: FileService);
+    execute(importContext: ImportContentContext): Promise<Response>;
+    calculateBufferSize(ecarFileSize: number): number;
+}

package/content/handlers/import/ecar-cleanup.d.ts

@@ -0,0 +1,8 @@
+import { FileService } from '../../../util/file/def/file-service';
+import { ImportContentContext } from '../..';
+import { Response } from '../../../api';
+export declare class EcarCleanup {
+    private fileService;
+    constructor(fileService: FileService);
+    execute(importContentContext: ImportContentContext): Promise<Response>;
+}

package/content/handlers/import/extract-ecar.d.ts

@@ -0,0 +1,11 @@
+import { ImportContentContext } from '../..';
+import { Response } from '../../../api';
+import { FileService } from '../../../util/file/def/file-service';
+import { ZipService } from '../../../util/zip/def/zip-service';
+export declare class ExtractEcar {
+    private fileService;
+    private zipService;
+    private readonly FILE_SIZE;
+    constructor(fileService: FileService, zipService: ZipService);
+    execute(importContext: ImportContentContext): Promise<Response>;
+}

package/content/handlers/import/extract-payloads.d.ts

@@ -0,0 +1,53 @@
+import { ImportContentContext } from '../..';
+import { SharedPreferences } from '../../../util/shared-preferences';
+import { Response } from '../../../api';
+import { FileService } from '../../../util/file/def/file-service';
+import { DbService } from '../../../db';
+import { GetContentDetailsHandler } from '../get-content-details-handler';
+import { ZipService } from '../../../util/zip/def/zip-service';
+import { AppConfig } from '../../../api/config/app-config';
+import { DeviceInfo } from '../../../util/device';
+import { EventsBusService } from '../../../events-bus';
+export declare class ExtractPayloads {
+    private fileService;
+    private zipService;
+    private appConfig;
+    private dbService;
+    private deviceInfo;
+    private getContentDetailsHandler;
+    private eventsBusService;
+    private sharedPreferences;
+    constructor(fileService: FileService, zipService: ZipService, appConfig: AppConfig, dbService: DbService, deviceInfo: DeviceInfo, getContentDetailsHandler: GetContentDetailsHandler, eventsBusService: EventsBusService, sharedPreferences: SharedPreferences);
+    execute(importContext: ImportContentContext): Promise<[Response, NodeJS.Timeout]>;
+    updateContentFileSizeInDB(importContext: ImportContentContext, commonContentModelsMap: any, payloadDestinationPathMap: any, result: any): Promise<void>;
+    updateContentDB(insertNewContentModels: any, updateNewContentModels: any, updateSize?: boolean): Promise<void>;
+    copyAssets(tempLocationPath: string, asset: string, payloadDestinationPath: string, useSubDirectories?: boolean): Promise<void>;
+    /**
+     * add or update the reference count for the content
+     *
+     */
+    getContentVisibility(existingContentInDb: any, objectType: any, isChildContent: boolean, previousVisibility: 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.
+     *
+     */
+    getContentState(existingContentInDb: any, contentState: number): number;
+    getBasePath(payLoadDestinationPath: any, doesContentExist: boolean, existingContentPath: string): string;
+    /**
+     * add or update the reference count for the content
+     *
+     */
+    private getReferenceCount;
+    private postImportProgressEvent;
+    private constructContentDBModel;
+    private createDirectories;
+    filterQuestionSetContent(items: any): any;
+    segregateQuestions(destinationRootDir: any, flattenedList: any): Promise<{
+        [key: string]: {
+            path: string | undefined;
+        };
+    }>;
+    private shouldDownloadQuestionSet;
+    private checkParentQustionSet;
+}

package/content/handlers/import/generate-import-share-telemetry.d.ts

@@ -0,0 +1,8 @@
+import { ImportContentContext } from '../..';
+import { Response } from '../../../api';
+import { TelemetryService } from '../../../telemetry';
+export declare class GenerateImportShareTelemetry {
+    private telemetryService;
+    constructor(telemetryService: TelemetryService);
+    execute(importContentContext: ImportContentContext): Promise<Response>;
+}

package/content/handlers/import/generate-interact-telemetry.d.ts

@@ -0,0 +1,8 @@
+import { TelemetryService } from '../../../telemetry';
+import { ImportContentContext } from '../..';
+import { Response } from '../../../api';
+export declare class GenerateInteractTelemetry {
+    private telemetryService;
+    constructor(telemetryService: TelemetryService);
+    execute(importContext: ImportContentContext, subType: any): Promise<Response>;
+}

package/content/handlers/import/hierarchy-manifest-conversion.d.ts

@@ -0,0 +1,11 @@
+import { Content } from "@project-sunbird/client-services/models";
+export declare class HierarchyManifestConversion {
+    private archive;
+    private identifierList;
+    hierarchyToManifestConversion(content: any): {
+        count: number;
+        items: Content[];
+    };
+    private recurssiveFunc;
+    private reorderData;
+}

package/content/handlers/import/update-size-on-device.d.ts

@@ -0,0 +1,18 @@
+import { FileService } from './../../../util/file/def/file-service';
+import { Response } from '../../../api';
+import { DbService } from '../../../db';
+import { Observable } from 'rxjs';
+import { SharedPreferences } from '../../../util/shared-preferences';
+export declare class UpdateSizeOnDevice {
+    private dbService;
+    private sharedPreferences;
+    private fileService;
+    constructor(dbService: DbService, sharedPreferences: SharedPreferences, fileService: FileService);
+    execute(): Promise<Response>;
+    private findAllChildContents;
+    updateAllRootContentSize(): Observable<any>;
+    private getSizeOnDevice;
+    private updateInDb;
+    private getMetaData;
+    private updateTextBookSize;
+}

package/content/handlers/import/validate-ecar.d.ts

@@ -0,0 +1,18 @@
+import { ImportContentContext } from '../..';
+import { Response } from '../../../api';
+import { FileService } from '../../../util/file/def/file-service';
+import { AppConfig } from '../../../api/config/app-config';
+import { DbService } from '../../../db';
+import { GetContentDetailsHandler } from '../get-content-details-handler';
+export declare class ValidateEcar {
+    private fileService;
+    private dbService;
+    private appConfig;
+    private getContentDetailsHandler;
+    constructor(fileService: FileService, dbService: DbService, appConfig: AppConfig, getContentDetailsHandler: GetContentDetailsHandler);
+    execute(importContext: ImportContentContext): Promise<Response>;
+    /**
+     * Skip the content.
+     */
+    private skipContent;
+}

package/content/handlers/import-n-export-handler.d.ts

@@ -0,0 +1,25 @@
+import { ContentEntry } from '../db/schema';
+import { DbService } from '../../db';
+import { FileService } from '../../util/file/def/file-service';
+import { DeviceInfo } from '../../util/device';
+export declare class ImportNExportHandler {
+    private deviceInfo;
+    private dbService?;
+    private fileService?;
+    private static readonly EKSTEP_CONTENT_ARCHIVE;
+    private static readonly SUPPORTED_MANIFEST_VERSION;
+    constructor(deviceInfo: DeviceInfo, dbService?: DbService | undefined, fileService?: FileService | undefined);
+    populateItems(contentsInDb: ContentEntry.SchemaMap[]): {
+        [key: string]: any;
+    }[];
+    populateItemList(contentWithAllChildren: {
+        [key: string]: any;
+    }[]): {
+        [key: string]: any;
+    }[];
+    getContentExportDBModelToExport(contentIds: string[]): Promise<ContentEntry.SchemaMap[]>;
+    generateManifestForArchive(items: any[]): {
+        [key: string]: any;
+    };
+    private findAllContentsWithIdentifiers;
+}

package/content/handlers/question-set-file-read-handler.d.ts

@@ -0,0 +1,11 @@
+import { StorageService } from '../../storage/def/storage-service';
+import { FileService } from '../../util/file/def/file-service';
+export declare class QuestionSetFileReadHandler {
+    private storageService;
+    private fileService;
+    constructor(storageService: StorageService, fileService: FileService);
+    getLocallyAvailableQuestion(questionIds: any, parentId: any): import("../../../node_modules/rxjs/internal/Observable").Observable<{
+        questions: any[];
+        count: 10;
+    }>;
+}

package/content/handlers/search-content-handler.d.ts

@@ -0,0 +1,33 @@
+import { ContentData, ContentImport, ContentSearchCriteria, ContentSearchFilter, ContentSearchResult, ContentServiceConfig, ContentSortCriteria, FilterValue, SearchResponse, SortOrder } from '..';
+import { AppConfig } from '../../api/config/app-config';
+import { SearchFilter, SearchRequest } from '../def/search-request';
+import { TelemetryService } from '../../telemetry';
+export declare class SearchContentHandler {
+    private appConfig;
+    private contentServiceConfig;
+    private telemetryService;
+    constructor(appConfig: AppConfig, contentServiceConfig: ContentServiceConfig, telemetryService: TelemetryService);
+    getSearchCriteria(requestMap: {
+        [key: string]: any;
+    }): ContentSearchCriteria;
+    getSearchContentRequest(criteria: ContentSearchCriteria): SearchRequest;
+    private getSearchFilter;
+    private getFilterRequest;
+    private addFiltersToRequest;
+    private getSearchRequest;
+    private getImpliedFilterValues;
+    getSortByRequest(sortCriteria?: ContentSortCriteria[]): {
+        [key: string]: SortOrder;
+    };
+    createFilterCriteria(previouscriteria: ContentSearchCriteria, facets: ContentSearchFilter[], appliedFilterMap: SearchFilter): ContentSearchCriteria;
+    addFilterValue(facets: ContentSearchFilter[], filters: any): void;
+    getFilterValuesWithAppliedFilter(facetValues: FilterValue[], appliedFilter: string[]): FilterValue[];
+    mapSearchResponse(previousContentCriteria: ContentSearchCriteria, searchResponse: SearchResponse, searchRequest: SearchRequest): ContentSearchResult;
+    getContentSearchFilter(contentIds: string[], status: string[], fields?: (keyof ContentData)[]): SearchRequest;
+    getDownloadUrl(contentData: ContentData, contentImport?: ContentImport): Promise<string>;
+    buildContentLoadingEvent(subtype: string, contentImport: ContentImport, contentType: string, contentVersion: string): Promise<boolean>;
+    private getSortOrder;
+    private getSearchType;
+    private getSortedFilterValuesWithAppliedFilters;
+    private mapFilterValues;
+}

package/content/impl/content-feedback-service-impl.d.ts

@@ -0,0 +1,13 @@
+import { ContentFeedback, ContentFeedbackFilterCriteria, ContentFeedbackService } from '..';
+import { Observable } from 'rxjs';
+import { DbService } from '../../db';
+import { ProfileService } from '../../profile';
+import { TelemetryService } from '../../telemetry';
+export declare class ContentFeedbackServiceImpl implements ContentFeedbackService {
+    private dbService;
+    private profileService;
+    private telemetryService;
+    constructor(dbService: DbService, profileService: ProfileService, telemetryService: TelemetryService);
+    getFeedback(contentFeedbackFilterCriteria: ContentFeedbackFilterCriteria): Observable<ContentFeedback[]>;
+    sendFeedback(contentFeedback: ContentFeedback): Observable<boolean>;
+}

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

@@ -0,0 +1,100 @@
+import { ChildContentRequest, Content, ContentDelete, ContentDeleteRequest, ContentDeleteResponse, ContentDetailRequest, ContentDownloadRequest, ContentExportRequest, ContentExportResponse, ContentFeedbackService, ContentImportRequest, ContentImportResponse, ContentMarkerRequest, ContentRequest, ContentSearchCriteria, ContentSearchResult, ContentService, ContentSpaceUsageSummaryRequest, ContentSpaceUsageSummaryResponse, EcarImportRequest, HierarchyInfo, RelevantContentRequest, RelevantContentResponsePlayer, SearchResponse } from '..';
+import { Observable } from 'rxjs';
+import { ApiRequestHandler, ApiService } from '../../api';
+import { ProfileService } from '../../profile';
+import { DbService } from '../../db';
+import { FileService } from '../../util/file/def/file-service';
+import { ZipService } from '../../util/zip/def/zip-service';
+import { TelemetryService } from '../../telemetry';
+import { SearchRequest } from '../def/search-request';
+import { DownloadService } from '../../util/download';
+import { DownloadCompleteDelegate } from '../../util/download/def/download-complete-delegate';
+import { EventsBusService } from '../../events-bus';
+import { SharedPreferences } from '../../util/shared-preferences';
+import { CachedItemStore } from '../../key-value-store';
+import { SdkServiceOnInitDelegate } from '../../sdk-service-on-init-delegate';
+import { Container } from 'inversify';
+import { SdkConfig } from '../../sdk-config';
+import { DeviceInfo } from '../../util/device';
+import { AppInfo } from '../../util/app';
+import { ContentAggregator } from '../handlers/content-aggregator';
+import { FormService } from '../../form';
+import { CourseService } from '../../course';
+import { NetworkInfoService } from '../../util/network';
+import { StorageService } from '../../storage/def/storage-service';
+export declare class ContentServiceImpl implements ContentService, DownloadCompleteDelegate, SdkServiceOnInitDelegate {
+    private sdkConfig;
+    private apiService;
+    private dbService;
+    private profileService;
+    private fileService;
+    private zipService;
+    private deviceInfo;
+    private telemetryService;
+    private contentFeedbackService;
+    private downloadService;
+    private sharedPreferences;
+    private eventsBusService;
+    private cachedItemStore;
+    private appInfo;
+    private networkInfoService;
+    private container;
+    private storageService;
+    private static readonly DOWNLOAD_DIR_NAME;
+    private static readonly KEY_IS_UPDATE_SIZE_ON_DEVICE_SUCCESSFUL;
+    private static readonly KEY_CONTENT_DELETE_REQUEST_LIST;
+    private readonly getContentDetailsHandler;
+    private readonly getContentHeirarchyHandler;
+    private readonly contentServiceConfig;
+    private readonly appConfig;
+    private readonly questionSetFileReadHandler;
+    private readonly getChildQuestionSetHandler;
+    private contentDeleteRequestSet;
+    private contentUpdateSizeOnDeviceTimeoutRef;
+    constructor(sdkConfig: SdkConfig, apiService: ApiService, dbService: DbService, profileService: ProfileService, fileService: FileService, zipService: ZipService, deviceInfo: DeviceInfo, telemetryService: TelemetryService, contentFeedbackService: ContentFeedbackService, downloadService: DownloadService, sharedPreferences: SharedPreferences, eventsBusService: EventsBusService, cachedItemStore: CachedItemStore, appInfo: AppInfo, networkInfoService: NetworkInfoService, container: Container, storageService: StorageService);
+    onInit(): Observable<undefined>;
+    getContentDetails(request: ContentDetailRequest): Observable<Content>;
+    getContentHeirarchy(request: ContentDetailRequest): Observable<Content>;
+    getContents(request: ContentRequest): Observable<Content[]>;
+    cancelImport(contentId: string): Observable<any>;
+    deleteContent(contentDeleteRequest: ContentDeleteRequest): Observable<ContentDeleteResponse[]>;
+    enqueueContentDelete(contentDeleteRequest: ContentDeleteRequest): Observable<void>;
+    clearContentDeleteQueue(): Observable<void>;
+    getContentDeleteQueue(): Observable<ContentDelete[]>;
+    exportContent(contentExportRequest: ContentExportRequest): Observable<ContentExportResponse>;
+    getChildContents(childContentRequest: ChildContentRequest): Observable<Content>;
+    getDownloadState(): Promise<any>;
+    importContent(contentImportRequest: ContentImportRequest): Observable<ContentImportResponse[]>;
+    importEcar(ecarImportRequest: EcarImportRequest): Observable<ContentImportResponse[]>;
+    nextContent(hierarchyInfo: HierarchyInfo[], currentContentIdentifier: string, shouldConvertBasePath?: boolean): Observable<Content>;
+    prevContent(hierarchyInfo: HierarchyInfo[], currentContentIdentifier: string, shouldConvertBasePath?: boolean): Observable<Content>;
+    getRelevantContent(request: RelevantContentRequest): Observable<RelevantContentResponsePlayer>;
+    subscribeForImportStatus(contentId: string): Observable<any>;
+    searchContent(contentSearchCriteria: ContentSearchCriteria, request?: {
+        [key: string]: any;
+    }, apiHandler?: ApiRequestHandler<SearchRequest, SearchResponse>, isFromContentAggregator?: boolean): Observable<ContentSearchResult>;
+    cancelDownload(contentId: string): Observable<undefined>;
+    setContentMarker(contentMarkerRequest: ContentMarkerRequest): Observable<boolean>;
+    onDownloadCompletion(request: ContentDownloadRequest): Observable<undefined>;
+    getContentSpaceUsageSummary(contentSpaceUsageSummaryRequest: ContentSpaceUsageSummaryRequest): Observable<ContentSpaceUsageSummaryResponse[]>;
+    buildContentAggregator(formService: FormService, courseService: CourseService, profileService: ProfileService): ContentAggregator;
+    getQuestionList(questionIds: string[], parentId?: any): Observable<any>;
+    getQuestionSetHierarchy(data: any): Observable<import("../../../node_modules/@project-sunbird/client-services/services/content/interface/cs-content-service").CsContentGetQuestionSetHierarchyResponse>;
+    getQuestionSetRead(contentId: string, params?: any): Observable<import("../../../node_modules/@project-sunbird/client-services/services/content/interface/cs-content-service").CsContentGetQuestionSetResponse>;
+    getQuestionSetChildren(questionSetId: string): Promise<any>;
+    formatSearchCriteria(requestMap: {
+        [key: string]: any;
+    }): ContentSearchCriteria;
+    private cleanupContent;
+    private getMimeType;
+    private handleContentDeleteRequestSetChanges;
+    private handleUpdateSizeOnDeviceFail;
+    private readonly contentServiceDelegate;
+    downloadTranscriptFile(transcriptReq: any): Promise<string | undefined>;
+    createTranscriptDir(req: any, dataDirectory: any): Promise<string | void>;
+    downloadTranscript(downloadRequest: any): Observable<{
+        path: string;
+    }>;
+    private copyFile;
+    private deleteFolder;
+}

package/content/index.d.ts

@@ -0,0 +1,9 @@
+export * from './def/content';
+export * from './def/response';
+export * from './def/content-service';
+export * from './def/requests';
+export * from './config/content-config';
+export * from './def/content-feedback-service';
+export * from './util/content-constants';
+export * from './def/content-event';
+export * from './util/content-mapper';