@aastrika_npmjs/sunbird-sdk 5.1.1

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

@@ -0,0 +1,7 @@
+export declare enum DownloadStatus {
+    STATUS_FAILED = 16,
+    STATUS_PAUSED = 4,
+    STATUS_PENDING = 1,
+    STATUS_RUNNING = 2,
+    STATUS_SUCCESSFUL = 8
+}

package/util/download/def/requests.d.ts

@@ -0,0 +1,20 @@
+export interface DownloadRequest {
+    withPriority?: number;
+    downloadId?: string;
+    title?: string;
+    identifier: string;
+    downloadUrl: string;
+    mimeType: string;
+    destinationFolder: string;
+    filename: string;
+    downloadedFilePath?: string;
+}
+export interface DownloadCancelRequest {
+    identifier: string;
+}
+export interface TrackDownloadRequest {
+    groupBy: {
+        fieldPath: string;
+        value: any;
+    };
+}

package/util/download/def/response.d.ts

@@ -0,0 +1,5 @@
+import { DownloadRequest } from './requests';
+export interface DownloadTracking {
+    completed: DownloadRequest[];
+    queued: DownloadRequest[];
+}

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

@@ -0,0 +1,38 @@
+import { DownloadCancelRequest, DownloadRequest, DownloadService, TrackDownloadRequest } from '..';
+import { Observable } from 'rxjs';
+import { SdkServiceOnInitDelegate } from '../../../sdk-service-on-init-delegate';
+import { EventsBusService } from '../../../events-bus';
+import { SharedPreferences } from '../../shared-preferences';
+import { DownloadCompleteDelegate } from '../def/download-complete-delegate';
+import { ContentDeleteListener } from '../../../content/def/content-delete-listener';
+import { DownloadTracking } from '../def/response';
+export declare class DownloadServiceImpl implements DownloadService, SdkServiceOnInitDelegate, ContentDeleteListener {
+    private eventsBusService;
+    private sharedPreferences;
+    private static readonly KEY_TO_DOWNLOAD_LIST;
+    private static readonly DOWNLOAD_DIR_NAME;
+    private currentDownloadRequest$;
+    private downloadCompleteDelegate?;
+    private sharedPreferencesSetCollection;
+    private completedDownloadRequestsCache;
+    constructor(eventsBusService: EventsBusService, sharedPreferences: SharedPreferences);
+    private static generateDownloadStartTelemetry;
+    private static generateDownloadCompleteTelemetry;
+    private static generateDownloadCancelTelemetry;
+    onInit(): Observable<undefined>;
+    download(downloadRequests: DownloadRequest[]): Observable<undefined>;
+    cancel(downloadCancelRequest: DownloadCancelRequest, generateTelemetry?: boolean): Observable<undefined>;
+    cancelAll(): Observable<void>;
+    registerOnDownloadCompleteDelegate(downloadCompleteDelegate: DownloadCompleteDelegate): void;
+    getActiveDownloadRequests(): Observable<DownloadRequest[]>;
+    private switchToNextDownloadRequest;
+    private addToDownloadList;
+    private removeFromDownloadList;
+    private removeAllFromDownloadList;
+    private handleDownloadCompletion;
+    private emitProgressInEventBus;
+    private getDownloadProgress;
+    private listenForDownloadProgressChanges;
+    trackDownloads(downloadStatRequest: TrackDownloadRequest): Observable<DownloadTracking>;
+    onContentDelete(identifier: string): void;
+}

package/util/download/index.d.ts

@@ -0,0 +1,5 @@
+export * from './def/download-event';
+export * from './def/download-service';
+export * from './def/download-status';
+export * from './def/requests';
+export * from './def/response';

package/util/encoders/encoder.d.ts

@@ -0,0 +1,4 @@
+export interface Encoder<E, D> {
+    encode(arg: E): D;
+    decode(arg: D): E;
+}

package/util/encoders/utf8-to-b64-encoder.d.ts

@@ -0,0 +1,5 @@
+import { Encoder } from './encoder';
+export declare class Utf8ToB64Encoder implements Encoder<string, string> {
+    decode(arg: string): string;
+    encode(arg: string): string;
+}

package/util/file/config/file-config.d.ts

@@ -0,0 +1,2 @@
+export interface FileConfig {
+}

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

@@ -0,0 +1,21 @@
+import { DirectoryEntry, Entry, FileEntry, Flags, IWriteOptions, Metadata, RemoveResult } from '../index';
+export interface FileService {
+    readAsText(path: string, file: string): Promise<string>;
+    readAsBinaryString(path: string, file: string): Promise<string>;
+    readFileFromAssets(fileName: string): Promise<string>;
+    writeFile(path: string, fileName: string, text: string, options: IWriteOptions): Promise<string>;
+    createFile(path: string, fileName: string, replace: boolean): Promise<FileEntry>;
+    removeFile(path: string): Promise<RemoveResult>;
+    getFile(directoryEntry: DirectoryEntry, fileName: string, flags: Flags): Promise<FileEntry>;
+    createDir(path: string, replace: boolean): Promise<DirectoryEntry>;
+    listDir(directoryPath: string): Promise<Entry[]>;
+    removeDir(path: string, dirName: string): Promise<RemoveResult>;
+    removeRecursively(path: string): Promise<RemoveResult>;
+    copyDir(path: string, dirName: string, newPath: string, newDirName: string): Promise<Entry>;
+    copyFile(path: string, fileName: string, newPath: string, newFileName: string): Promise<Entry>;
+    getMetaData(path: string): Promise<Metadata>;
+    exists(path: string): Promise<Entry>;
+    getTempLocation(destinationPath: string): Promise<DirectoryEntry>;
+    getFreeDiskSpace(): Promise<number>;
+    getDirectorySize(path: string): Promise<number>;
+}

package/util/file/errors/no-file-found.d.ts

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

package/util/file/impl/file-service-impl.d.ts

@@ -0,0 +1,98 @@
+import { FileService } from '../def/file-service';
+import { DirectoryEntry, Entry, FileEntry, Flags, IWriteOptions, Metadata, RemoveResult } from '../index';
+export declare class FileServiceImpl implements FileService {
+    private fileSystem;
+    private initialized;
+    init(): void;
+    readAsText(path: string, filePath: string): Promise<string>;
+    readAsBinaryString(path: string, filePath: string): Promise<string>;
+    readFileFromAssets(fileName: string): Promise<string>;
+    writeFile(path: string, fileName: string, text: string, options?: IWriteOptions): Promise<any>;
+    /**
+     * Creates a new file in the specific path.
+     * The replace boolean value determines whether to replace an existing file with the same name.
+     * If an existing file exists and the replace value is false, the promise will fail and return an error.
+     *
+     * @param {string} path  Base FileSystem. Please refer to the iOS and Android filesystem above
+     * @param {string} fileName Name of file to create
+     * @param {boolean} replace If true, replaces file with same name. If false returns error
+     * @returns {Promise<FileEntry>} Returns a Promise that resolves to a FileEntry or rejects with an error.
+     */
+    createFile(path: string, fileName: string, replace: boolean): Promise<FileEntry>;
+    getFile(directoryEntry: DirectoryEntry, fileName: string, flags: Flags): Promise<FileEntry>;
+    /**
+     * Removes a file from a desired location.
+     *
+     * @param {string} path  Base FileSystem. Please refer to the iOS and Android filesystem above
+     * @returns {Promise<RemoveResult>} Returns a Promise that resolves to a RemoveResult or rejects with an error.
+     */
+    removeFile(path: string): Promise<RemoveResult>;
+    createDir(path: string, replace: boolean): Promise<DirectoryEntry>;
+    /**
+     * List files and directory from a given path.
+     *
+     * @param {string} directoryPath. Please refer to the iOS and Android filesystems above
+     * @returns {Promise<Entry[]>} Returns a Promise that resolves to an array of Entry objects or rejects with an error.
+     */
+    listDir(directoryPath: string): Promise<Entry[]>;
+    removeDir(path: string, dirName: string): Promise<RemoveResult>;
+    /**
+     * Removes all files and the directory from a desired location.
+     *
+     * @param {string} path Base FileSystem. Please refer to the iOS and Android filesystem above
+     * @returns {Promise<RemoveResult>} Returns a Promise that resolves with a RemoveResult or rejects with an error.
+     */
+    removeRecursively(path: string): Promise<RemoveResult>;
+    /**
+     * Copy a directory in various methods. If destination directory exists, will fail to copy.
+     *
+     * @param {string} path Base FileSystem. Please refer to the iOS and Android filesystems above
+     * @param {string} dirName Name of directory to copy
+     * @param {string} newPath Base FileSystem of new location
+     * @param {string} newDirName New name of directory to copy to (leave blank to remain the same)
+     * @returns {Promise<Entry>} Returns a Promise that resolves to the new Entry object or rejects with an error.
+     */
+    copyDir(path: string, dirName: string, newPath: string, newDirName: string): Promise<Entry>;
+    /**
+     * Copy a file in various methods. If file exists, will fail to copy.
+     *
+     * @param {string} path Base FileSystem. Please refer to the iOS and Android filesystem above
+     * @param {string} fileName Name of file to copy
+     * @param {string} newPath Base FileSystem of new location
+     * @param {string} newFileName New name of file to copy to (leave blank to remain the same)
+     * @returns {Promise<Entry>} Returns a Promise that resolves to an Entry or rejects with an error.
+     */
+    copyFile(path: string, fileName: string, newPath: string, newFileName: string): Promise<Entry>;
+    exists(path: string): Promise<Entry>;
+    getTempLocation(destinationPath: string): Promise<DirectoryEntry>;
+    getFreeDiskSpace(): Promise<number>;
+    /**
+     * Resolves a local file system URL
+     * @param fileUrl {string} file system url
+     * @returns {Promise<Entry>}
+     */
+    resolveLocalFilesystemUrl(fileUrl: string): Promise<Entry>;
+    getMetaData(path: string | Entry): Promise<Metadata>;
+    getExternalApplicationStorageDirectory(): string;
+    getDirectorySize(path: string): Promise<number>;
+    size(entry: Entry): Promise<number>;
+    private readEntries;
+    private readFile;
+    private resolveDirectoryUrl;
+    private remove;
+    private copy;
+    private getDirectory;
+    private rimraf;
+    private createWriter;
+    /**
+     * Write content to FileEntry.
+     * @hidden
+     * Write to an existing file.
+     * @param {FileEntry} fe file entry object
+     * @param {string | Blob | ArrayBuffer} text text content or blob to write
+     * @param {IWriteOptions} options replace file if set to true. See WriteOptions for more information.
+     * @returns {Promise<FileEntry>}  Returns a Promise that resolves to updated file entry or rejects with an error.
+     */
+    private writeFileEntry;
+    private write;
+}

package/util/file/index.d.ts

@@ -0,0 +1,271 @@
+/** This interface represents a file system. */
+export interface FileSystem {
+    name: string;
+    /** The root directory of the file system. */
+    root: DirectoryEntry;
+}
+/**
+ * An abstract interface representing entries in a file system,
+ * each of which may be a File or DirectoryEntry.
+ */
+export interface Entry {
+    /** Entry is a file. */
+    isFile: boolean;
+    /** Entry is a directory. */
+    isDirectory: boolean;
+    /** The name of the entry, excluding the path leading to it. */
+    name: string;
+    /** The full absolute path from the root to the entry. */
+    fullPath: string;
+    /** The file system on which the entry resides. */
+    filesystem: FileSystem;
+    nativeURL: string;
+    /**
+     * Look up metadata about this entry.
+     * @param successCallback A callback that is called with the time of the last modification.
+     * @param errorCallback   A callback that is called when errors happen.
+     */
+    getMetadata(successCallback: (metadata: Metadata) => void, errorCallback?: (error: FileError) => void): void;
+    /**
+     * Move an entry to a different location on the file system. It is an error to try to:
+     *     move a directory inside itself or to any child at any depth;move an entry into its parent if a name different
+     *     from its current one isn't provided;
+     *     move a file to a path occupied by a directory;
+     *     move a directory to a path occupied by a file;
+     *     move any element to a path occupied by a directory which is not empty.
+     * A move of a file on top of an existing file must attempt to delete and replace that file.
+     * A move of a directory on top of an existing empty directory must attempt to delete and replace that directory.
+     * @param parent  The directory to which to move the entry.
+     * @param newName The new name of the entry. Defaults to the Entry's current name if unspecified.
+     * @param successCallback A callback that is called with the Entry for the new location.
+     * @param errorCallback   A callback that is called when errors happen.
+     */
+    moveTo(parent: DirectoryEntry, newName?: string, successCallback?: (entry: Entry) => void, errorCallback?: (error: FileError) => void): void;
+    /**
+     * Copy an entry to a different location on the file system. It is an error to try to:
+     *     copy a directory inside itself or to any child at any depth;
+     *     copy an entry into its parent if a name different from its current one isn't provided;
+     *     copy a file to a path occupied by a directory;
+     *     copy a directory to a path occupied by a file;
+     *     copy any element to a path occupied by a directory which is not empty.
+     *     A copy of a file on top of an existing file must attempt to delete and replace that file.
+     *     A copy of a directory on top of an existing empty directory must attempt to delete and replace that directory.
+     * Directory copies are always recursive--that is, they copy all contents of the directory.
+     * @param parent The directory to which to move the entry.
+     * @param newName The new name of the entry. Defaults to the Entry's current name if unspecified.
+     * @param successCallback A callback that is called with the Entry for the new object.
+     * @param errorCallback A callback that is called when errors happen.
+     */
+    copyTo(parent: DirectoryEntry, newName?: string, successCallback?: (entry: Entry) => void, errorCallback?: (error: FileError) => void): void;
+    /**
+     * Returns a URL that can be used as the src attribute of a <video> or <audio> tag.
+     * If that is not possible, construct a cdvfile:// URL.
+     * @return string URL
+     */
+    toURL(): string;
+    /**
+     * Return a URL that can be passed across the bridge to identify this entry.
+     * @return string URL that can be passed across the bridge to identify this entry
+     */
+    toInternalURL(): string;
+    /**
+     * Deletes a file or directory. It is an error to attempt to delete a directory that is not empty. It is an error to attempt to delete
+     * the root directory of a filesystem.
+     * @param successCallback A callback that is called on success.
+     * @param errorCallback   A callback that is called when errors happen.
+     */
+    remove(successCallback: () => void, errorCallback?: (error: FileError) => void): void;
+    /**
+     * Look up the parent DirectoryEntry containing this Entry. If this Entry is the root of its filesystem, its parent is itself.
+     * @param successCallback A callback that is called with the time of the last modification.
+     * @param errorCallback   A callback that is called when errors happen.
+     */
+    getParent(successCallback: (entry: Entry) => void, errorCallback?: (error: FileError) => void): void;
+}
+/** This interface supplies information about the state of a file or directory. */
+export interface Metadata {
+    /** This is the time at which the file or directory was last modified. */
+    modificationTime: Date;
+    /** The size of the file, in bytes. This must return 0 for directories. */
+    size: number;
+}
+/** This interface represents a directory on a file system. */
+export interface DirectoryEntry extends Entry {
+    /**
+     * Creates a new DirectoryReader to read Entries from this Directory.
+     */
+    createReader(): DirectoryReader;
+    /**
+     * Creates or looks up a file.
+     * @param path    Either an absolute path or a relative path from this DirectoryEntry
+     *                to the file to be looked up or created.
+     *                It is an error to attempt to create a file whose immediate parent does not yet exist.
+     * @param options If create and exclusive are both true, and the path already exists, getFile must fail.
+     *                If create is true, the path doesn't exist, and no other error occurs, getFile must create it as a zero-length file
+     *                and return a corresponding FileEntry.
+     *                If create is not true and the path doesn't exist, getFile must fail.
+     *                If create is not true and the path exists, but is a directory, getFile must fail.
+     *                Otherwise, if no other error occurs, getFile must return a FileEntry corresponding to path.
+     * @param successCallback A callback that is called to return the File selected or created.
+     * @param errorCallback   A callback that is called when errors happen.
+     */
+    getFile(path: string, options?: Flags, successCallback?: (entry: FileEntry) => void, errorCallback?: (error: FileError) => void): void;
+    /**
+     * Creates or looks up a directory.
+     * @param path    Either an absolute path or a relative path from this DirectoryEntry
+     *                to the directory to be looked up or created.
+     *                It is an error to attempt to create a directory whose immediate parent does not yet exist.
+     * @param options If create and exclusive are both true and the path already exists, getDirectory must fail.
+     *                If create is true, the path doesn't exist, and no other error occurs, getDirectory must create and return a
+     *                corresponding DirectoryEntry.
+     *                If create is not true and the path doesn't exist, getDirectory must fail.
+     *                If create is not true and the path exists, but is a file, getDirectory must fail.
+     *                Otherwise, if no other error occurs, getDirectory must return a DirectoryEntry corresponding to path.
+     * @param successCallback A callback that is called to return the Directory selected or created.
+     * @param errorCallback   A callback that is called when errors happen.
+     */
+    getDirectory(path: string, options?: Flags, successCallback?: (entry: DirectoryEntry) => void, errorCallback?: (error: FileError) => void): void;
+    /**
+     * Deletes a directory and all of its contents, if any. In the event of an error (e.g. trying
+     * to delete a directory that contains a file that cannot be removed), some of the contents
+     * of the directory may be deleted. It is an error to attempt to delete the root directory of a filesystem.
+     * @param successCallback A callback that is called on success.
+     * @param errorCallback   A callback that is called when errors happen.
+     */
+    removeRecursively(successCallback: () => void, errorCallback?: (error: FileError) => void): void;
+}
+/**
+ * This dictionary is used to supply arguments to methods
+ * that look up or create files or directories.
+ */
+export interface Flags {
+    /** Used to indicate that the user wants to create a file or directory if it was not previously there. */
+    create?: boolean;
+    /** By itself, exclusive must have no effect. Used with create, it must cause getFile and getDirectory to fail if the target path
+     * already exists. */
+    exclusive?: boolean;
+}
+/**
+ * This interface lets a user list files and directories in a directory. If there are
+ * no additions to or deletions from a directory between the first and last call to
+ * readEntries, and no errors occur, then:
+ *     A series of calls to readEntries must return each entry in the directory exactly once.
+ *     Once all entries have been returned, the next call to readEntries must produce an empty array.
+ *     If not all entries have been returned, the array produced by readEntries must not be empty.
+ *     The entries produced by readEntries must not include the directory itself ["."] or its parent [".."].
+ */
+export interface DirectoryReader {
+    /**
+     * Read the next block of entries from this directory.
+     * @param successCallback Called once per successful call to readEntries to deliver the next
+     *                        previously-unreported set of Entries in the associated Directory.
+     *                        If all Entries have already been returned from previous invocations
+     *                        of readEntries, successCallback must be called with a zero-length array as an argument.
+     * @param errorCallback   A callback indicating that there was an error reading from the Directory.
+     */
+    readEntries(successCallback: (entries: Entry[]) => void, errorCallback?: (error: FileError) => void): void;
+}
+/** This interface represents a file on a file system. */
+export interface FileEntry extends Entry {
+    /**
+     * Creates a new FileWriter associated with the file that this FileEntry represents.
+     * @param successCallback A callback that is called with the new FileWriter.
+     * @param errorCallback   A callback that is called when errors happen.
+     */
+    createWriter(successCallback: (writer: FileWriter) => void, errorCallback?: (error: FileError) => void): void;
+    /**
+     * Returns a File that represents the current state of the file that this FileEntry represents.
+     * @param successCallback A callback that is called with the File.
+     * @param errorCallback   A callback that is called when errors happen.
+     */
+    file(successCallback: (file: File) => void, errorCallback?: (error: FileError) => void): void;
+}
+/**
+ * This interface provides methods to monitor the asynchronous writing of blobs
+ * to disk using progress events and event handler attributes.
+ */
+interface FileSaver extends EventTarget {
+    /**
+     * The FileSaver object can be in one of 3 states. The readyState attribute, on getting,
+     * must return the current state, which must be one of the following values:
+     *     INIT
+     *     WRITING
+     *     DONE
+     */
+    readyState: number;
+    /** Handler for writestart events. */
+    onwritestart: (event: ProgressEvent) => void;
+    /** Handler for progress events. */
+    onprogress: (event: ProgressEvent) => void;
+    /** Handler for write events. */
+    onwrite: (event: ProgressEvent) => void;
+    /** Handler for abort events. */
+    onabort: (event: ProgressEvent) => void;
+    /** Handler for error events. */
+    onerror: (event: ProgressEvent) => void;
+    /** Handler for writeend events. */
+    onwriteend: (event: ProgressEvent) => void;
+    /** The last error that occurred on the FileSaver. */
+    error: Error;
+    /** Terminate file operation */
+    abort(): void;
+}
+/**
+ * This interface expands on the FileSaver interface to allow for multiple write
+ * actions, rather than just saving a single Blob.
+ */
+export interface FileWriter extends FileSaver {
+    /**
+     * The byte offset at which the next write to the file will occur. This always less or equal than length.
+     * A newly-created FileWriter will have position set to 0.
+     */
+    position: number;
+    /**
+     * The length of the file. If the user does not have read access to the file,
+     * this will be the highest byte offset at which the user has written.
+     */
+    length: number;
+    /**
+     * Write the supplied data to the file at position.
+     * @param {Blob|string} data The blob to write.
+     */
+    write(data: Blob | string): void;
+    /**
+     * The file position at which the next write will occur.
+     * @param offset If nonnegative, an absolute byte offset into the file.
+     *               If negative, an offset back from the end of the file.
+     */
+    seek(offset: number): void;
+    /**
+     * Changes the length of the file to that specified. If shortening the file, data beyond the new length
+     * will be discarded. If extending the file, the existing data will be zero-padded up to the new length.
+     * @param size The size to which the length of the file is to be adjusted, measured in bytes.
+     */
+    truncate(size: number): void;
+}
+export interface FileError {
+    /** Error code */
+    code: number;
+}
+export interface RemoveResult {
+    success: boolean;
+    fileRemoved: Entry;
+}
+/**
+ * When an error occurs, the following callback is made.
+ */
+export declare type ErrorCallback = (err: FileError) => void;
+/**
+ * This export interface is the callback used to look up Entry objects.
+ */
+export declare type EntryCallback = (entry: Entry) => void;
+export declare enum LocalFileSystem {
+    PERSISTENT = 1,
+    TEMPORARY = 0
+}
+export interface IWriteOptions {
+    replace?: boolean;
+    append?: boolean;
+    truncate?: number;
+}
+export {};

package/util/file/util/file-util.d.ts

@@ -0,0 +1,9 @@
+export declare class FileUtil {
+    static getFileExtension(filePath: string): string;
+    static getFileName(filePath: string): string;
+    static getParentDir(directoryPath: string): string;
+    static getDirectoryName(filePath: string): string;
+    static getTempDirPath(externalFilesDir: string): string;
+    static isFreeSpaceAvailable(deviceAvailableFreeSpace: number, fileSpace: number, bufferSize: number): boolean;
+    static getDirecory(path: string): string;
+}

package/util/file/util/path.d.ts

@@ -0,0 +1,6 @@
+export declare class Path {
+    static ASSETS_PATH: string;
+    static dirPathFromFilePath(filePath: string): string;
+    static fileNameFromFilePath(filePath: string): string;
+    static getAssetPath(): string;
+}

package/util/list/comparator.d.ts

@@ -0,0 +1,3 @@
+export interface Comparator<V> {
+    isEqual(v: V): boolean;
+}

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

@@ -0,0 +1,11 @@
+import { ListNode } from './list-node';
+import { Comparator } from './comparator';
+export declare class LinkedList<T extends Comparator<T>> {
+    protected head: ListNode<T>;
+    constructor();
+    static fromJson(json: string): LinkedList<any>;
+    add(value: T): void;
+    search(value: T): ListNode<T> | null;
+    forEach(consumer: Function): void;
+    toJson(): string;
+}

package/util/list/list-node.d.ts

@@ -0,0 +1,6 @@
+export declare class ListNode<T> {
+    private _next;
+    private _value;
+    next: ListNode<T>;
+    value: T;
+}

package/util/network/def/network-info-service.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from 'rxjs';
+import { NetworkStatus } from './network-status';
+export interface NetworkInfoService {
+    networkStatus$: Observable<NetworkStatus>;
+}

package/util/network/def/network-status.d.ts

@@ -0,0 +1,4 @@
+export declare enum NetworkStatus {
+    ONLINE = "ONLINE",
+    OFFLINE = "OFFLINE"
+}

package/util/network/impl/network-info-service-impl.d.ts

@@ -0,0 +1,7 @@
+import { NetworkInfoService, NetworkStatus } from '..';
+import { Observable } from 'rxjs';
+export declare class NetworkInfoServiceImpl implements NetworkInfoService {
+    networkStatus$: Observable<NetworkStatus>;
+    private networkStatusSource;
+    constructor();
+}

package/util/network/index.d.ts

@@ -0,0 +1,2 @@
+export * from './def/network-info-service';
+export * from './def/network-status';

package/util/number-util.d.ts

@@ -0,0 +1,5 @@
+export declare class NumberUtil {
+    static toFixed(input: any): number;
+    static parseInt(input: any): number;
+    static round(input: any): number;
+}

package/util/object-util.d.ts

@@ -0,0 +1,7 @@
+export declare class ObjectUtil {
+    static equals(a: any, b: any): boolean;
+    static getPropDiff(newObj: {}, oldObj: {}): string[];
+    static getTruthyProps(obj: {}): string[];
+    static toOrderedString(obj: {}): string;
+    static withDeeplyOrderedKeys(obj: {}): {};
+}

package/util/queue/queue.d.ts

@@ -0,0 +1,8 @@
+import { LinkedList } from '../list/linked-list';
+import { ListNode } from '../list/list-node';
+import { Comparator } from '../list/comparator';
+export declare class Queue<T extends Comparator<T>> extends LinkedList<T> {
+    constructor();
+    enque(value: T): void;
+    deque(): ListNode<T>;
+}

package/util/search-history/db/schema.d.ts

@@ -0,0 +1,17 @@
+export declare namespace SearchHistoryEntry {
+    const TABLE_NAME = "search_history";
+    const _ID = "_id";
+    const COLUMN_NAME_USER_ID = "uid";
+    const COLUMN_NAME_QUERY = "query";
+    const COLUMN_NAME_TIME_STAMP = "time_stamp";
+    const COLUMN_NAME_NAMESPACE = "namespace";
+    interface SchemaMap {
+        [_ID]?: string;
+        [COLUMN_NAME_USER_ID]: string;
+        [COLUMN_NAME_QUERY]: string;
+        [COLUMN_NAME_TIME_STAMP]: number;
+        [COLUMN_NAME_NAMESPACE]: string;
+    }
+    const getCreateEntry: (() => string);
+    const deleteTable: (() => string);
+}

package/util/search-history/def/requests.d.ts

@@ -0,0 +1,9 @@
+export interface AddEntryRequest {
+    query: string;
+    namespace: string;
+}
+export interface GetEntriesRequest {
+    namespace: string;
+    like?: string;
+    limit: number;
+}

package/util/search-history/def/search-entry.d.ts

@@ -0,0 +1,5 @@
+export interface SearchEntry {
+    uid: string;
+    query: string;
+    timestamp: number;
+}

package/util/search-history/def/search-history-service.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from 'rxjs';
+import { AddEntryRequest, GetEntriesRequest } from './requests';
+import { SearchEntry } from './search-entry';
+export interface SearchHistoryService {
+    addEntry(request: AddEntryRequest): Observable<undefined>;
+    getEntries(request: GetEntriesRequest): Observable<SearchEntry[]>;
+}

package/util/search-history/impl/search-history-service-impl.d.ts

@@ -0,0 +1,13 @@
+import { SearchEntry, SearchHistoryService } from '..';
+import { Observable } from 'rxjs';
+import { AddEntryRequest, GetEntriesRequest } from '../def/requests';
+import { DbService } from '../../../db';
+import { ProfileService } from '../../../profile';
+export declare class SearchHistoryServiceImpl implements SearchHistoryService {
+    private dbService;
+    private profileService;
+    private static MAX_USER_SEARCH_HISTORY_ENTRIES;
+    constructor(dbService: DbService, profileService: ProfileService);
+    addEntry({ query, namespace }: AddEntryRequest): Observable<undefined>;
+    getEntries({ like, limit, namespace }: GetEntriesRequest): Observable<SearchEntry[]>;
+}