@aastrika_npmjs/sunbird-sdk 5.1.1

package/telemetry/def/telemetry-model.d.ts

@@ -0,0 +1,193 @@
+import { LogLevel, ShareItemType } from './telemetry-constants';
+export declare class Actor {
+    static readonly TYPE_SYSTEM: string;
+    static readonly TYPE_USER: string;
+    id: string;
+    type: string;
+    constructor();
+}
+export declare class ReportSummary {
+    uid: string;
+    contentId: string;
+    name: string;
+    lastUsedTime: number;
+    noOfQuestions: number;
+    correctAnswers: number;
+    totalTimespent: number;
+    hierarchyData: string;
+    totalMaxScore: number;
+    totalScore: number;
+    totalQuestionsScore: number;
+}
+export declare class Context {
+    env: string;
+    cdata: Array<CorrelationData>;
+    channel: string;
+    pdata: ProducerData;
+    sid: string;
+    did: string;
+    rollup: Rollup;
+}
+export declare class DeviceSpecification {
+    os: string;
+    make: string;
+    id: string;
+    mem: number;
+    idisk: number;
+    edisk: number;
+    scrn: number;
+    camera: string;
+    cpu: string;
+    sims: number;
+    cap: Array<string>;
+}
+export declare class Etags {
+    app: Array<string>;
+    partner: Array<string>;
+    dims: Array<string>;
+}
+export declare class ExData {
+    type: string;
+    data: string;
+}
+export declare class GameData {
+    id: string;
+    ver: string;
+}
+export declare class CorrelationData {
+    id: string;
+    type: string;
+}
+export declare class Rollup {
+    l1?: string;
+    l2?: string;
+    l3?: string;
+    l4?: string;
+}
+export declare class Visit {
+    objid: string;
+    objtype: string;
+    objver: string;
+    section: string;
+    index: number;
+}
+export declare class ProducerData {
+    id: string;
+    pid: string;
+    ver: string;
+    ProducerData(): void;
+}
+export declare class Search {
+    type: string;
+    query: string;
+    filters: {
+        [index: string]: any;
+    };
+    sort: {
+        [index: string]: any;
+    };
+    correlationid: string;
+    size: number;
+}
+export declare class TelemetryObject {
+    rollup?: Rollup;
+    readonly id: string;
+    readonly type: string;
+    readonly version: string;
+    constructor(id: string, type: string, version: string);
+    setRollup(value: Rollup): void;
+}
+export declare class ProcessedEventModel {
+    msgId: string;
+    data: string;
+    numberOfEvents: number;
+    priority: number;
+}
+export declare enum AuditState {
+    AUDIT_CREATED = "Created",
+    AUDIT_UPDATED = "Updated",
+    AUDIT_DELETED = "Deleted"
+}
+export declare namespace SunbirdTelemetry {
+    abstract class Telemetry {
+        private static readonly TELEMETRY_VERSION;
+        eid: string;
+        mid: string;
+        ets: number;
+        ver: string;
+        actor: Actor;
+        context: Context;
+        object: TelemetryObject;
+        edata: any;
+        tags: string[];
+        protected constructor(eid: string);
+    }
+    class End extends Telemetry {
+        private static readonly EID;
+        constructor(type: string | undefined, mode: string | undefined, duration: number | undefined, pageid: string | undefined, summaryList: {}[] | undefined, env: string, objId?: string, objType?: string, objVer?: string, rollup?: Rollup, correlationData?: Array<CorrelationData>);
+    }
+    class Start extends Telemetry {
+        private static readonly EID;
+        constructor(type: string | undefined, dspec: DeviceSpecification | undefined, loc: string | undefined, mode: string | undefined, duration: number | undefined, pageid: string | undefined, env: string, objId?: string, objType?: string, objVer?: string, rollup?: Rollup, correlationData?: Array<CorrelationData>);
+    }
+    class Summary extends Telemetry {
+        private static readonly EID;
+        constructor(type: string, starttime: number, endtime: number, timespent: number, pageviews: number, interactions: number, env: string, mode?: string, envsummary?: {
+            env: string;
+            timespent: number;
+            visits: number;
+        }[], eventsummary?: {
+            id: string;
+            count: number;
+        }[], pagesummary?: {
+            id: string;
+            type: string;
+            env: string;
+            timespent: number;
+            visits: number;
+        }[], extra?: {
+            id: string;
+            value: string;
+        }[], correlationData?: Array<CorrelationData>, objId?: string, objType?: string, objVer?: string, rollup?: Rollup);
+    }
+    class Interact extends Telemetry {
+        private static readonly EID;
+        constructor(type: string, subtype: string, id: string | undefined, pageid: string | undefined, pos: {
+            [key: string]: string;
+        }[] | undefined, valuesMap: {
+            [key: string]: any;
+        } | undefined, env: string, objId?: string, objType?: string, objVer?: string, rollup?: Rollup, correlationData?: Array<CorrelationData>);
+    }
+    class Impression extends Telemetry {
+        private static readonly EID;
+        constructor(type: string | undefined, subtype: string | undefined, pageid: string | undefined, visits: Visit[] | undefined, env: string, objId?: string, objType?: string, objVer?: string, rollup?: Rollup, correlationData?: Array<CorrelationData>);
+    }
+    class Log extends Telemetry {
+        private static readonly EID;
+        constructor(type: string | undefined, level: LogLevel | undefined, message: string | undefined, pageid: string | undefined, params: {}[] | undefined, env: string, actorType: any);
+    }
+    class Error extends Telemetry {
+        private static readonly EID;
+        constructor(errorCode: string | undefined, errorType: string | undefined, stacktrace: string | undefined, pageid: string | undefined);
+    }
+    class Interrupt extends Telemetry {
+        private static readonly EID;
+        constructor(type: string, pageid: string | undefined);
+    }
+    class Share extends Telemetry {
+        private static readonly EID;
+        constructor(dir: string | undefined, type: string | undefined, items: Array<{
+            [index: string]: any;
+        }> | undefined, correlationData?: Array<CorrelationData>, objId?: string, objType?: string, objVer?: string, rollUp?: Rollup);
+        addItem(type: ShareItemType | string, origin: string, identifier: string, pkgVersion: number, transferCount: number, size: string): void;
+        capitalize(input: any): string;
+    }
+    class Feedback extends Telemetry {
+        private static readonly EID;
+        constructor(rating: number | undefined, comments: string | undefined, env: string, objId: string | undefined, objType: string | undefined, objVer: string | undefined, commentid: string | undefined, commenttxt: string | undefined);
+    }
+    class Audit extends Telemetry {
+        private static readonly EID;
+        constructor(env: string, actor: Actor, currentState: AuditState, updatedProperties: string[] | undefined, type: string | undefined, objId?: string, objType?: string, objVer?: string, correlationData?: Array<CorrelationData>, rollup?: Rollup);
+    }
+}

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

@@ -0,0 +1,31 @@
+import { TelemetryStat } from './telemetry-stat';
+import { TelemetrySyncStat } from './telemetry-sync-stat';
+import { Observable } from 'rxjs';
+import { TelemetryAuditRequest, TelemetryEndRequest, TelemetryErrorRequest, TelemetryFeedbackRequest, TelemetryImportRequest, TelemetryImpressionRequest, TelemetryInteractRequest, TelemetryInterruptRequest, TelemetryLogRequest, TelemetryShareRequest, TelemetryStartRequest, TelemetrySummaryRequest, TelemetrySyncRequest } from './requests';
+import { Context, CorrelationData } from './telemetry-model';
+import { SdkServiceOnInitDelegate } from '../../sdk-service-on-init-delegate';
+import { TelemetryAutoSyncService } from '..';
+import { SdkServicePreInitDelegate } from '../../sdk-service-pre-init-delegate';
+export interface TelemetryService extends SdkServiceOnInitDelegate, SdkServicePreInitDelegate {
+    autoSync: TelemetryAutoSyncService;
+    saveTelemetry(request: string): Observable<boolean>;
+    audit(request: TelemetryAuditRequest): Observable<boolean>;
+    start(request: TelemetryStartRequest): Observable<boolean>;
+    interact(request: TelemetryInteractRequest): Observable<boolean>;
+    impression(request: TelemetryImpressionRequest): Observable<boolean>;
+    end(request: TelemetryEndRequest): Observable<boolean>;
+    feedback(request: TelemetryFeedbackRequest): Observable<boolean>;
+    log(request: TelemetryLogRequest): Observable<boolean>;
+    share(request: TelemetryShareRequest): Observable<boolean>;
+    error(request: TelemetryErrorRequest): Observable<boolean>;
+    interrupt(request: TelemetryInterruptRequest): Observable<boolean>;
+    importTelemetry(telemetryImportRequest: TelemetryImportRequest): Observable<boolean>;
+    getTelemetryStat(): Observable<TelemetryStat>;
+    sync(telemetrySyncRequest?: TelemetrySyncRequest): Observable<TelemetrySyncStat>;
+    lastSyncedTimestamp(): Observable<number | undefined>;
+    resetDeviceRegisterTTL(): Observable<undefined>;
+    buildContext(): Observable<Context>;
+    updateCampaignParameters(params: CorrelationData[]): any;
+    summary(request: TelemetrySummaryRequest): Observable<boolean>;
+    populateGlobalCorRelationData(params: CorrelationData[]): any;
+}

package/telemetry/def/telemetry-stat.d.ts

@@ -0,0 +1,4 @@
+export interface TelemetryStat {
+    unSyncedEventCount: number;
+    lastSyncTime: number;
+}

package/telemetry/def/telemetry-sync-preprocessor.d.ts

@@ -0,0 +1,3 @@
+export interface TelemetrySyncPreprocessor {
+    process(input: any): any;
+}

package/telemetry/def/telemetry-sync-stat.d.ts

@@ -0,0 +1,6 @@
+export interface TelemetrySyncStat {
+    syncedEventCount: number;
+    syncTime: number;
+    syncedFileSize: number;
+    error?: any;
+}

package/telemetry/errors/invalid-input-for-sync-preprocessor-error.d.ts

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

package/telemetry/handler/import/generate-import-telemetry-share.d.ts

@@ -0,0 +1,9 @@
+import { ImportTelemetryContext, TelemetryService } from '../..';
+import { Response } from '../../../api';
+import { DbService } from '../../../db';
+export declare class GenerateImportTelemetryShare {
+    private dbService;
+    private telemetryService;
+    constructor(dbService: DbService, telemetryService: TelemetryService);
+    execute(importContext: ImportTelemetryContext): Promise<Response>;
+}

package/telemetry/handler/import/transport-processed-telemetry.d.ts

@@ -0,0 +1,9 @@
+import { DbService } from '../../../db';
+import { ImportTelemetryContext } from '../..';
+import { Response } from '../../../api';
+export declare class TransportProcessedTelemetry {
+    private dbService;
+    constructor(dbService: DbService);
+    execute(importContext: ImportTelemetryContext): Promise<Response>;
+    private saveProccessedTelemetryToDB;
+}

package/telemetry/handler/import/update-imported-telemetry-metadata.d.ts

@@ -0,0 +1,8 @@
+import { DbService } from '../../../db';
+import { Response } from '../../../api';
+import { ImportTelemetryContext } from '../..';
+export declare class UpdateImportedTelemetryMetadata {
+    private dbService;
+    constructor(dbService: DbService);
+    execute(importContext: ImportTelemetryContext): Promise<Response>;
+}

package/telemetry/handler/import/validate-telemetry-metadata.d.ts

@@ -0,0 +1,9 @@
+import { DbService } from '../../../db';
+import { ImportTelemetryContext } from '../..';
+import { Response } from '../../../api';
+export declare class ValidateTelemetryMetadata {
+    private dbService;
+    constructor(dbService: DbService);
+    execute(importContext: ImportTelemetryContext): Promise<Response>;
+    private getImportTypes;
+}

package/telemetry/handler/telemetry-sync-handler.d.ts

@@ -0,0 +1,41 @@
+import { ApiRequestHandler, ApiService } from '../../api';
+import { TelemetrySyncRequest, TelemetrySyncStat } from '..';
+import { KeyValueStore } from '../../key-value-store';
+import { SdkConfig } from '../../sdk-config';
+import { DeviceInfo } from '../../util/device';
+import { DbService } from '../../db';
+import { SharedPreferences } from '../../util/shared-preferences';
+import { AppInfo } from '../../util/app';
+import { DeviceRegisterService } from '../../device-register';
+import { Observable } from 'rxjs';
+import { NetworkQueue } from '../../api/network-queue';
+export declare class TelemetrySyncHandler implements ApiRequestHandler<TelemetrySyncRequest, TelemetrySyncStat> {
+    private dbService;
+    private sdkConfig;
+    private deviceInfo;
+    private sharedPreferences;
+    private appInfoService;
+    private deviceRegisterService;
+    private keyValueStore?;
+    private apiService?;
+    private networkQueue?;
+    static readonly TELEMETRY_LOG_MIN_ALLOWED_OFFSET_KEY: string;
+    private static readonly LAST_SYNCED_DEVICE_REGISTER_ATTEMPT_TIME_STAMP_KEY;
+    private static readonly LAST_SYNCED_DEVICE_REGISTER_IS_SUCCESSFUL_KEY;
+    static readonly TELEMETRY_ENDPOINT: string;
+    private static readonly REGISTER_API_SUCCESS_TTL;
+    private static readonly REGISTER_API_FAILURE_TTL;
+    private readonly preprocessors;
+    private readonly telemetryConfig;
+    private readonly apiConfig;
+    constructor(dbService: DbService, sdkConfig: SdkConfig, deviceInfo: DeviceInfo, sharedPreferences: SharedPreferences, appInfoService: AppInfo, deviceRegisterService: DeviceRegisterService, keyValueStore?: KeyValueStore | undefined, apiService?: ApiService | undefined, networkQueue?: NetworkQueue | undefined);
+    resetDeviceRegisterTTL(): Observable<undefined>;
+    handle({ ignoreSyncThreshold, ignoreAutoSyncMode }: TelemetrySyncRequest): Observable<TelemetrySyncStat>;
+    processEventsBatch(isForceSynced: boolean): Observable<number>;
+    private registerDevice;
+    private hasTelemetryThresholdCrossed;
+    private fetchEvents;
+    private processEvents;
+    private persistinNetworkQueue;
+    private deleteEvents;
+}

package/telemetry/impl/decorator-impl.d.ts

@@ -0,0 +1,26 @@
+import { Context, CorrelationData, SunbirdTelemetry, TelemetryDecorator } from '..';
+import { DeviceInfo } from '../../util/device';
+import { AppInfo } from '../../util/app';
+import { SdkConfig } from '../../sdk-config';
+import { CodePushExperimentService } from '../../codepush-experiment';
+import { ProfileSession } from '../../profile';
+import Telemetry = SunbirdTelemetry.Telemetry;
+export declare class TelemetryDecoratorImpl implements TelemetryDecorator {
+    private sdkConfig;
+    private deviceInfo;
+    private appInfo;
+    private codePushExperimentService;
+    private apiConfig;
+    constructor(sdkConfig: SdkConfig, deviceInfo: DeviceInfo, appInfo: AppInfo, codePushExperimentService: CodePushExperimentService);
+    decorate(event: Telemetry, profileSession: ProfileSession, gid?: string, offset?: number, channelId?: string, campaignParameters?: CorrelationData[], globalCData?: CorrelationData[]): any;
+    private patchActor;
+    private patchContext;
+    private patchPData;
+    prepare(event: Telemetry, priority: any): {
+        event: string;
+        event_type: string;
+        timestamp: number;
+        priority: number;
+    };
+    buildContext(sid: string, channelId: string, context: Context, campaignParameters?: CorrelationData[], globalCData?: CorrelationData[]): Context;
+}

package/telemetry/impl/process-event.d.ts

@@ -0,0 +1,5 @@
+export declare class EventProcessor {
+    process(eventJsonArray: Array<any>): void;
+    private getParams;
+    private formatCurrentDate;
+}

package/telemetry/impl/string-to-byte-array-preprocessor.d.ts

@@ -0,0 +1,4 @@
+import { TelemetrySyncPreprocessor } from '../def/telemetry-sync-preprocessor';
+export declare class StringToByteArrayPreprocessor implements TelemetrySyncPreprocessor {
+    process(input: any): any;
+}

package/telemetry/impl/string-to-gzipped-string.d.ts

@@ -0,0 +1,4 @@
+import { TelemetrySyncPreprocessor } from '../def/telemetry-sync-preprocessor';
+export declare class StringToGzippedString implements TelemetrySyncPreprocessor {
+    process(input: any): any;
+}

package/telemetry/impl/telemetry-entries-to-string-preprocessor.d.ts

@@ -0,0 +1,4 @@
+import { TelemetrySyncPreprocessor } from '../def/telemetry-sync-preprocessor';
+export declare class TelemetryEntriesToStringPreprocessor implements TelemetrySyncPreprocessor {
+    process(input: any): any;
+}

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

@@ -0,0 +1,74 @@
+import { DbService } from '../../db';
+import { Context, TelemetryAuditRequest, TelemetryDecorator, TelemetryEndRequest, TelemetryErrorRequest, TelemetryFeedbackRequest, TelemetryImportRequest, TelemetryImpressionRequest, TelemetryInteractRequest, TelemetryInterruptRequest, TelemetryLogRequest, TelemetryService, TelemetryShareRequest, TelemetryStartRequest, TelemetryStat, TelemetrySummaryRequest, TelemetrySyncRequest, TelemetrySyncStat } from '..';
+import { ProfileService } from '../../profile';
+import { GroupServiceDeprecated } from '../../group-deprecated';
+import { KeyValueStore } from '../../key-value-store';
+import { ApiService } from '../../api';
+import { DeviceInfo } from '../../util/device';
+import { EventsBusService } from '../../events-bus';
+import { FileService } from '../../util/file/def/file-service';
+import { FrameworkService } from '../../framework';
+import { NetworkInfoService } from '../../util/network';
+import { SdkConfig } from '../../sdk-config';
+import { ErrorLoggerService } from '../../error';
+import { SharedPreferences } from '../../util/shared-preferences';
+import { AppInfo } from '../../util/app';
+import { DeviceRegisterService } from '../../device-register';
+import { Observable } from 'rxjs';
+import { TelemetryAutoSyncServiceImpl } from '../util/telemetry-auto-sync-service-impl';
+import { CourseService } from '../../course';
+import { NetworkQueue } from '../../api/network-queue';
+import { CorrelationData } from '../def/telemetry-model';
+import { SdkServiceOnInitDelegate } from '../../sdk-service-on-init-delegate';
+import { SdkServicePreInitDelegate } from '../../sdk-service-pre-init-delegate';
+export declare class TelemetryServiceImpl implements TelemetryService, SdkServiceOnInitDelegate, SdkServicePreInitDelegate {
+    private dbService;
+    private decorator;
+    private profileService;
+    private groupService;
+    private keyValueStore;
+    private apiService;
+    private sdkConfig;
+    private deviceInfo;
+    private eventsBusService;
+    private fileService;
+    private frameworkService;
+    private networkInfoService;
+    private errorLoggerService;
+    private sharedPreferences;
+    private appInfoService;
+    private deviceRegisterService;
+    private courseService;
+    private networkQueue;
+    private _lastSyncedTimestamp$;
+    private telemetryAutoSyncService?;
+    private telemetryConfig;
+    private campaignParameters;
+    private globalCdata;
+    readonly autoSync: TelemetryAutoSyncServiceImpl;
+    constructor(dbService: DbService, decorator: TelemetryDecorator, profileService: ProfileService, groupService: GroupServiceDeprecated, keyValueStore: KeyValueStore, apiService: ApiService, sdkConfig: SdkConfig, deviceInfo: DeviceInfo, eventsBusService: EventsBusService, fileService: FileService, frameworkService: FrameworkService, networkInfoService: NetworkInfoService, errorLoggerService: ErrorLoggerService, sharedPreferences: SharedPreferences, appInfoService: AppInfo, deviceRegisterService: DeviceRegisterService, courseService: CourseService, networkQueue: NetworkQueue);
+    preInit(): Observable<undefined>;
+    onInit(): Observable<undefined>;
+    saveTelemetry(request: string): Observable<boolean>;
+    audit({ env, actor, currentState, updatedProperties, type, objId, objType, objVer, correlationData, rollUp }: TelemetryAuditRequest): Observable<boolean>;
+    end({ type, mode, duration, pageId, summaryList, env, objId, objType, objVer, rollup, correlationData }: TelemetryEndRequest): Observable<boolean>;
+    error(request: TelemetryErrorRequest): Observable<boolean>;
+    impression({ type, subType, pageId, visits, env, objId, objType, objVer, rollup, correlationData }: TelemetryImpressionRequest): Observable<boolean>;
+    interact({ type, subType, id, pageId, pos, env, rollup, valueMap, correlationData, objId, objType, objVer }: TelemetryInteractRequest): Observable<boolean>;
+    log({ type, level, message, pageId, params, env, actorType }: TelemetryLogRequest): Observable<boolean>;
+    share({ dir, type, items, correlationData, objId, objType, objVer, rollUp }: TelemetryShareRequest): Observable<boolean>;
+    feedback({ rating, comments, env, objId, objType, objVer, commentid, commenttxt }: TelemetryFeedbackRequest): Observable<boolean>;
+    start({ type, deviceSpecification, loc, mode, duration, pageId, env, objId, objType, objVer, rollup, correlationData }: TelemetryStartRequest): Observable<boolean>;
+    summary({ type, starttime, endtime, timespent, pageviews, interactions, env, mode, envsummary, eventsummary, pagesummary, extra, correlationData, objId, objType, objVer, rollup }: TelemetrySummaryRequest): Observable<boolean>;
+    interrupt({ type, pageId }: TelemetryInterruptRequest): Observable<boolean>;
+    importTelemetry(importTelemetryRequest: TelemetryImportRequest): Observable<boolean>;
+    getTelemetryStat(): Observable<TelemetryStat>;
+    resetDeviceRegisterTTL(): Observable<undefined>;
+    sync(telemetrySyncRequest?: TelemetrySyncRequest): Observable<TelemetrySyncStat>;
+    lastSyncedTimestamp(): Observable<number | undefined>;
+    buildContext(): Observable<Context>;
+    private decorateAndPersist;
+    updateCampaignParameters(params: CorrelationData[]): void;
+    populateGlobalCorRelationData(params: CorrelationData[]): void;
+    private getInitialUtmParameters;
+}

package/telemetry/index.d.ts

@@ -0,0 +1,9 @@
+export * from './def/telemetry-decorator';
+export * from './def/telemetry-model';
+export * from './def/telemetry-service';
+export * from './def/telemetry-stat';
+export * from './def/telemetry-sync-stat';
+export * from './def/telemetry-constants';
+export * from './def/requests';
+export * from './util/telemetry-auto-sync-service';
+export * from './util/telemetry-auto-sync-modes';

package/telemetry/util/telemetry-auto-sync-modes.d.ts

@@ -0,0 +1,5 @@
+export declare enum TelemetryAutoSyncModes {
+    OFF = "OFF",
+    OVER_WIFI = "OVER_WIFI",
+    ALWAYS_ON = "ALWAYS_ON"
+}

package/telemetry/util/telemetry-auto-sync-service-impl.d.ts

@@ -0,0 +1,17 @@
+import { TelemetryAutoSyncModes, TelemetryService } from '..';
+import { Observable } from 'rxjs';
+import { TelemetryAutoSyncService } from './telemetry-auto-sync-service';
+import { SharedPreferences } from '../../util/shared-preferences';
+export declare class TelemetryAutoSyncServiceImpl implements TelemetryAutoSyncService {
+    private telemetryService;
+    private sharedPreferences;
+    private static DOWNLOAD_SPEED_TELEMETRY_SYNC_INTERVAL;
+    private shouldSync;
+    private static generateDownloadSpeedTelemetry;
+    constructor(telemetryService: TelemetryService, sharedPreferences: SharedPreferences);
+    getSyncMode(): Observable<TelemetryAutoSyncModes | undefined>;
+    setSyncMode(mode: TelemetryAutoSyncModes): Observable<void>;
+    start(intervalTime: number): Observable<undefined>;
+    pause(): void;
+    continue(): void;
+}

package/telemetry/util/telemetry-auto-sync-service.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import { TelemetryAutoSyncModes } from './telemetry-auto-sync-modes';
+export interface TelemetryAutoSyncService {
+    getSyncMode(): Observable<TelemetryAutoSyncModes | undefined>;
+    setSyncMode(mode: TelemetryAutoSyncModes): Observable<void>;
+    start(intervalTime: number): Observable<undefined>;
+    pause(): void;
+    continue(): void;
+}

package/telemetry/util/telemetry-logger.d.ts

@@ -0,0 +1,4 @@
+import { TelemetryService } from '..';
+export declare class TelemetryLogger {
+    static readonly log: TelemetryService;
+}

package/util/app/def/app-info.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from 'rxjs';
+export interface AppInfo {
+    init(): any;
+    getAppName(): string;
+    getVersionName(): string;
+    getFirstAccessTimestamp(): Observable<string>;
+}

package/util/app/impl/app-info-impl.d.ts

@@ -0,0 +1,19 @@
+import { SdkConfig } from '../../../sdk-config';
+import { AppInfo } from '..';
+import { SharedPreferences } from '../../shared-preferences';
+import { Observable } from 'rxjs';
+export declare class AppInfoImpl implements AppInfo {
+    private sdkConfig;
+    private sharedPreferences;
+    private versionName;
+    private appName;
+    constructor(sdkConfig: SdkConfig, sharedPreferences: SharedPreferences);
+    getVersionName(): string;
+    getAppName(): string;
+    init(): Promise<void>;
+    /** @internal */
+    getBuildConfigValue(packageName: any, property: any): Promise<string>;
+    /** @internal */
+    getFirstAccessTimestamp(): Observable<string>;
+    private setFirstAccessTimestamp;
+}

package/util/app/index.d.ts

@@ -0,0 +1 @@
+export * from './def/app-info';

package/util/array-util.d.ts

@@ -0,0 +1,6 @@
+export declare class ArrayUtil {
+    static joinPreservingQuotes(array: string[]): string;
+    static isEmpty<T>(array: T[]): boolean;
+    static contains(array: string[], item: string): boolean;
+    static deDupe(array: any): string[];
+}

package/util/device/def/device-info.d.ts

@@ -0,0 +1,33 @@
+import { Observable } from 'rxjs';
+import { StorageDestination } from '../../../storage';
+export interface DeviceSpec {
+    idisk: number;
+    cap: any[];
+    mem: number;
+    os: string;
+    cpu: string;
+    scrn: number;
+    sims: number;
+    id: string;
+    camera: string;
+    edisk: number;
+    make: string;
+}
+export interface StorageVolume {
+    storageDestination: StorageDestination;
+    info: {
+        availableSize: number;
+        totalSize: string;
+        state: string;
+        path: string;
+        contentStoragePath: string;
+        isRemovable: boolean;
+    };
+}
+export interface DeviceInfo {
+    getDeviceID(): string;
+    getDeviceSpec(): Observable<DeviceSpec>;
+    getAvailableInternalMemorySize(): Observable<string>;
+    getStorageVolumes(): Observable<StorageVolume[]>;
+    isKeyboardShown(): Observable<boolean>;
+}

package/util/device/impl/device-info-impl.d.ts

@@ -0,0 +1,12 @@
+import { DeviceInfo, DeviceSpec, StorageVolume } from '..';
+import { Observable } from 'rxjs';
+export declare class DeviceInfoImpl implements DeviceInfo {
+    private readonly deviceId;
+    private deviceSpec;
+    constructor();
+    getDeviceID(): string;
+    getDeviceSpec(): Observable<DeviceSpec>;
+    getAvailableInternalMemorySize(): Observable<string>;
+    getStorageVolumes(): Observable<StorageVolume[]>;
+    isKeyboardShown(): Observable<boolean>;
+}

package/util/device/index.d.ts

@@ -0,0 +1 @@
+export * from './def/device-info';

package/util/download/def/download-complete-delegate.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from 'rxjs';
+import { DownloadRequest } from './requests';
+export interface DownloadCompleteDelegate {
+    onDownloadCompletion(downloadRequest: DownloadRequest): Observable<undefined>;
+}

package/util/download/def/download-event.d.ts

@@ -0,0 +1,20 @@
+import { DownloadStatus } from './download-status';
+import { EventsBusEvent } from '../../../events-bus';
+export interface DownloadEvent extends EventsBusEvent {
+    type: DownloadEventType;
+}
+export interface DownloadProgress extends DownloadEvent {
+    payload: {
+        downloadId: string;
+        identifier: string;
+        progress: number;
+        status: DownloadStatus;
+        bytesDownloaded: number;
+        totalSizeInBytes: number;
+    };
+}
+export declare enum DownloadEventType {
+    START = "START",
+    PROGRESS = "PROGRESS",
+    END = "END"
+}

package/util/download/def/download-service.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { SdkServiceOnInitDelegate } from '../../../sdk-service-on-init-delegate';
+import { DownloadCancelRequest, DownloadRequest, TrackDownloadRequest } from './requests';
+import { DownloadCompleteDelegate } from './download-complete-delegate';
+import { ContentDeleteListener } from '../../../content/def/content-delete-listener';
+import { DownloadTracking } from './response';
+export interface DownloadService extends SdkServiceOnInitDelegate, ContentDeleteListener {
+    download(downloadRequests: DownloadRequest[]): Observable<undefined>;
+    cancel(cancelRequest: DownloadCancelRequest): Observable<undefined>;
+    cancelAll(): Observable<void>;
+    registerOnDownloadCompleteDelegate(downloadCompleteDelegate: DownloadCompleteDelegate): void;
+    getActiveDownloadRequests(): Observable<DownloadRequest[]>;
+    trackDownloads(downloadStatRequest: TrackDownloadRequest): Observable<DownloadTracking>;
+}