@jayesol/jayeson.lib.sports 2.2.6 → 2.2.7

package/lib/core.js

@@ -0,0 +1,497 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var FSRepoImpl_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecycleBin = exports.TTLRemoveCheck = exports.TTLRestoreCheck = exports.TTLCheck = exports.TTLOutgoing = exports.TTLType = exports.TTLConfig = exports.Delta = exports.FSRepoImpl = exports.AbstractFSRepo = exports.FSREPO_IMPL = void 0;
+const data_structure_1 = require("./data_structure");
+const Collections = __importStar(require("typescript-collections"));
+const T = __importStar(require("ts-promise"));
+//imports required for dependency injection
+require("reflect-metadata");
+const injection_js_1 = require("injection-js");
+const jayeson_lib_record_1 = require("@jayesol/jayeson.lib.record");
+const message_class_1 = require("./message_class");
+const mutable_1 = require("./mutable");
+const merge_1 = require("./merge");
+const data_structure_2 = require("./data_structure");
+exports.FSREPO_IMPL = new injection_js_1.InjectionToken('FSRepoInstance');
+let AbstractFSRepo = class AbstractFSRepo {
+    constructor() {
+        this._handlers = new Collections.Set();
+    }
+    handlers() {
+        return this._handlers;
+    }
+    appendSnapshot(stream, mergeable) {
+        throw new Error("appendSnapshot is not implemented");
+    }
+    getSnapshot(streamName) {
+        throw new Error("getSnapshot is not implemented");
+    }
+    registerSnapshotHandler(ssHandler) {
+        this.handlers().add(ssHandler);
+    }
+    deRegisterSnapshotHandler(ssHandler) {
+        this.handlers().remove(ssHandler);
+    }
+    getRegisteredHandlers() {
+        return this.handlers().toArray();
+    }
+    push(outgoing) {
+        throw new Error("push is not implemented");
+    }
+    isReady(stream) {
+        return null;
+    }
+};
+AbstractFSRepo = __decorate([
+    (0, injection_js_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], AbstractFSRepo);
+exports.AbstractFSRepo = AbstractFSRepo;
+let FSRepoImpl = FSRepoImpl_1 = class FSRepoImpl extends AbstractFSRepo {
+    constructor(outputStreamName, sportsGroup) {
+        super();
+        this.outputStreamName = outputStreamName;
+        this.sportsGroup = sportsGroup;
+        this._head = null;
+        let instance = this;
+        this.fssEndReceived = new T.Promise((resolve, reject) => {
+            instance.promiseResolver = resolve;
+            instance.promiseRejector = reject;
+        });
+    }
+    head() {
+        return this._head;
+    }
+    appendSnapshot(stream, logic) {
+        //single threaded, locking is unnecessary.
+        if (this._head == null) {
+            this.result = logic.apply(null);
+            this._head = this.result.getAfter();
+        }
+        else {
+            this.result = logic.apply(this._head);
+            this._head = this.result.getAfter();
+        }
+        return this.result.getDeltaOut();
+    }
+    getSnapshot(streamName = "") {
+        if (this._head == null) {
+            return data_structure_1.IndexedSnapshotImpl.EMPTY_SNAPSHOT;
+        }
+        return this._head;
+    }
+    getTtlRemoveSnapshot() {
+        if (this._head == null) {
+            return [];
+        }
+        let ttlRemoveCheck = new TTLRemoveCheck(null, this._head.getPartitions().toArray(), this.outputStreamName);
+        return [ttlRemoveCheck];
+    }
+    push(outgoing) {
+        if (outgoing.msgType() == this.sportsGroup.FULLSNAPSHOT_START()) {
+            //ignore this
+        }
+        else if (outgoing.msgType() == this.sportsGroup.FULLSNAPSHOT_END()) {
+            this.promiseResolver(true);
+        }
+        else {
+            let _instance = this;
+            this._handlers.forEach(function (handler) {
+                handler.process(_instance.outputStreamName, outgoing);
+            });
+        }
+    }
+    isReady(stream) {
+        return this.fssEndReceived;
+    }
+};
+FSRepoImpl.outputStream = new injection_js_1.InjectionToken('aggregatedStreamName');
+FSRepoImpl = FSRepoImpl_1 = __decorate([
+    (0, injection_js_1.Injectable)(),
+    __param(0, (0, injection_js_1.Inject)(FSRepoImpl_1.outputStream)),
+    __metadata("design:paramtypes", [String, message_class_1.SportsFeedMessageGroup])
+], FSRepoImpl);
+exports.FSRepoImpl = FSRepoImpl;
+class Delta {
+    constructor(_incoming, _after, _before) {
+        this._incoming = _incoming;
+        this._after = _after;
+        this._before = _before;
+    }
+    incoming() {
+        return this._incoming;
+    }
+    msgType() {
+        return this._incoming.msgType();
+    }
+    after() {
+        return this._after;
+    }
+    delta() {
+        return this._incoming.data();
+    }
+    before() {
+        return this._before;
+    }
+}
+exports.Delta = Delta;
+let TTLConfig = class TTLConfig {
+    constructor() {
+        this.livettl = 180000;
+        this.todayttl = 180000;
+        this.earlyttl = 180000;
+        // Boolean to see if ttl is enabled or not.
+        // If set to false,ttl will be disabled even though ttl values are set
+        this.enableTtl = true;
+    }
+    getLivettl() {
+        return this.livettl;
+    }
+    setLivettl(livettl) {
+        this.livettl = livettl;
+    }
+    getTodayttl() {
+        return this.todayttl;
+    }
+    setTodayttl(todayttl) {
+        this.todayttl = todayttl;
+    }
+    getEarlyttl() {
+        return this.earlyttl;
+    }
+    setEarlyttl(earlyttl) {
+        this.earlyttl = earlyttl;
+    }
+    getRunInterval() {
+        if (!this.enableTtl) {
+            return -1;
+        }
+        let liveTTL = this.getLivettl();
+        let todayTTL = this.getTodayttl();
+        let earlyTTL = this.getEarlyttl();
+        let sleepDuration = Math.min(liveTTL, todayTTL, earlyTTL) / 2;
+        return (sleepDuration < 1000) ? 10000 : sleepDuration;
+    }
+    isEnableTtl() {
+        return this.enableTtl;
+    }
+    setEnableTtl(enableTtl) {
+        this.enableTtl = enableTtl;
+    }
+};
+TTLConfig = __decorate([
+    (0, injection_js_1.Injectable)()
+], TTLConfig);
+exports.TTLConfig = TTLConfig;
+var TTLType;
+(function (TTLType) {
+    TTLType[TTLType["REMOVE"] = 0] = "REMOVE";
+    TTLType[TTLType["RESTORE"] = 1] = "RESTORE";
+})(TTLType = exports.TTLType || (exports.TTLType = {}));
+class TTLOutgoing extends Delta {
+    constructor(ttlType, incoming, after, before) {
+        super(incoming, after, before);
+        this.ttlType = ttlType;
+    }
+    getTtlType() {
+        return this.ttlType;
+    }
+}
+exports.TTLOutgoing = TTLOutgoing;
+class TTLCheck {
+    constructor(ttlType, recycleBin, keys, stream) {
+        this.ttlType = ttlType;
+        this.recycleBin = recycleBin;
+        this.keys = keys;
+        this.stream = stream;
+    }
+    getKeys() {
+        return this.keys;
+    }
+    getKeysMapping() {
+        let mapping = new Collections.Dictionary();
+        this.keys.forEach(key => {
+            mapping.setValue(key, new Date().getTime());
+        });
+        return mapping;
+    }
+    getTtlType() {
+        return this.ttlType;
+    }
+    getRecycleBin() {
+        return this.recycleBin;
+    }
+    setRecycleBin(recycleBin) {
+        this.recycleBin = recycleBin;
+    }
+    getStream() {
+        return this.stream;
+    }
+}
+exports.TTLCheck = TTLCheck;
+class TTLRestoreCheck extends TTLCheck {
+    constructor(recycleBin, keys, stream) {
+        super(TTLType.RESTORE, recycleBin, keys, stream);
+    }
+    apply(before) {
+        let restoredSS = before;
+        let atLeastOneRestored = false;
+        let restoredKeys = new Collections.Dictionary();
+        let matches = {};
+        let ttlRestoredList = [];
+        //for each key in this object
+        this.getKeys().forEach((key, val) => {
+            //check if key is present in recycle bin
+            if (this.getRecycleBin().containData(key)) {
+                atLeastOneRestored = true;
+                let restoreTime = new Date().getTime();
+                restoredKeys.setValue(key, restoreTime);
+                matches = this.getRecycleBin().copyData(key, matches);
+                //if it is present, restore data
+                this.ttlRestoreWrapper = this.getRecycleBin().restoreData(new data_structure_2.TTLWrapper(), restoredSS, key, restoreTime);
+                restoredSS = this.ttlRestoreWrapper.getRemainingSs();
+                ttlRestoredList.push(this.ttlRestoreWrapper.getRestoredSs());
+            }
+        });
+        let ttlOut = [];
+        let wrap = new data_structure_2.MergeableWrapper();
+        wrap.setAfter(restoredSS);
+        if (atLeastOneRestored) {
+            console.log("restore ----->" + JSON.stringify(restoredKeys.keys()));
+            return merge_1.DeltaTransformingLogicImpl.transformTTLRestore(ttlRestoredList, this.getRecycleBin().getGrp(), this.getStream(), before, restoredSS, matches, restoredKeys);
+        }
+        else {
+            //mark as refresh if not a snapshot message
+            let incoming = new data_structure_1.Incoming(this.getRecycleBin().getGrp().ADMIN_REFRESH(), this.getStream(), new data_structure_1.IndexedSnapshotImpl(matches, this.getKeysMapping()));
+            ttlOut.push(new TTLOutgoing(this.getTtlType(), incoming, restoredSS, before));
+            wrap.setDeltaOut(ttlOut);
+            return wrap;
+        }
+    }
+}
+exports.TTLRestoreCheck = TTLRestoreCheck;
+class TTLRemoveCheck extends TTLCheck {
+    constructor(recycleBin, keys, stream) {
+        super(TTLType.REMOVE, recycleBin, keys, stream);
+    }
+    apply(before) {
+        let allKeys = before.getPartitionMap();
+        let keysRemoved = new Collections.Dictionary();
+        let removedSnapshot = before;
+        let ttlRemoveList = [];
+        let ttlConfig = this.getRecycleBin().getTtlConfig();
+        let atLeastOneKeyRemoved = false;
+        for (let key of this.getKeys()) {
+            let threshold = 0;
+            if (!allKeys.containsKey(key)) {
+                continue;
+            }
+            switch (key.oddType()) {
+                case jayeson_lib_record_1.OddType.LIVE:
+                    threshold = allKeys.getValue(key) + ttlConfig.getLivettl();
+                    break;
+                case jayeson_lib_record_1.OddType.TODAY:
+                    threshold = allKeys.getValue(key) + ttlConfig.getTodayttl();
+                    break;
+                case jayeson_lib_record_1.OddType.EARLY:
+                    threshold = allKeys.getValue(key) + ttlConfig.getEarlyttl();
+                    break;
+            }
+            if (threshold < new Date().getTime()) {
+                //remove expired odds
+                atLeastOneKeyRemoved = true;
+                keysRemoved.setValue(key, allKeys.getValue(key));
+                this.ttlRemoveWrapper = this.getRecycleBin().removeData(new data_structure_2.TTLWrapper(), removedSnapshot, key);
+                removedSnapshot = this.ttlRemoveWrapper.getRemainingSs();
+                ttlRemoveList.push(this.ttlRemoveWrapper.getRemovedSs());
+            }
+        }
+        let ttlOut = [];
+        if (atLeastOneKeyRemoved) {
+            console.log("reseting ----->" + JSON.stringify(keysRemoved.keys()));
+            return merge_1.DeltaTransformingLogicImpl.transformTTLRemove(ttlRemoveList, this.getRecycleBin().getGrp(), this.getStream(), before, removedSnapshot, keysRemoved);
+        }
+        else {
+            let wrapper = new data_structure_2.MergeableWrapper();
+            let incoming = new data_structure_1.Incoming(this.getRecycleBin().getGrp().ADMIN_REFRESH(), this.getStream(), new data_structure_1.IndexedSnapshotImpl({}, this.getKeysMapping()));
+            ttlOut.push(new TTLOutgoing(this.getTtlType(), incoming, removedSnapshot, before));
+            wrapper.setDeltaOut(ttlOut);
+            wrapper.setAfter(removedSnapshot);
+            return wrapper;
+        }
+    }
+}
+exports.TTLRemoveCheck = TTLRemoveCheck;
+let RecycleBin = class RecycleBin {
+    constructor(ttlConfig, grp, fsRepo) {
+        this.ttlConfig = ttlConfig;
+        this.grp = grp;
+        this.fsRepo = fsRepo;
+        this.expiredMatches = new Collections.Dictionary();
+        this.ttlStatus = new Collections.Set();
+    }
+    /**
+     * Remove the data for a given PartitionKey from a snapshot and return the
+     * modified snapshot. The removed data will be stored in this recycle bin.
+     *
+     * @param snapshot
+     * @param key
+     */
+    removeData(ttlRemoveWrapper, snapshot, key) {
+        if (!snapshot.getPartitions().contains(key)) {
+            ttlRemoveWrapper.setRemainingSs(snapshot);
+            ttlRemoveWrapper.setRemovedSs(null);
+            return ttlRemoveWrapper;
+        }
+        let sBuilder = mutable_1.BuilderProvider.getSnapshotBuilder(snapshot);
+        // remove the data with given PartitionKey from sBuilder
+        // and get a snapshot containing only the removed data.
+        let removedData = sBuilder.reset(key).build();
+        //save the data to be removed
+        let result = sBuilder.build();
+        this.expiredMatches.setValue(key, removedData);
+        ttlRemoveWrapper.setRemovedSs(removedData);
+        ttlRemoveWrapper.setRemainingSs(result);
+        // return the snapshot with PartitionKey data removed
+        return ttlRemoveWrapper;
+    }
+    /**
+     * Retrieves the data in this bin with given PartitionKey and combine it with
+     * the given snapshot.
+     *
+     * @param parent
+     * @param key
+     */
+    restoreData(ttlRestore, parent, key, restoreTime) {
+        let partition = this.expiredMatches.getValue(key);
+        // Return if expired data doesn't contain given key
+        if (partition == null) {
+            ttlRestore.setRemainingSs(parent);
+            ttlRestore.setRestoredSs(null);
+            return ttlRestore;
+        }
+        //update restored partition's refresh time with the restore time
+        let updateTime = new Collections.Dictionary();
+        updateTime.setValue(key, restoreTime);
+        let sBuilder = mutable_1.BuilderProvider.getSnapshotBuilder(partition);
+        sBuilder.markPartitionAsUpdated(key, restoreTime);
+        partition = sBuilder.build();
+        parent = merge_1.SnapshotUtil.combineSnapshots(this.getGrp().DATA_INSERT_MATCH(), partition, parent).getAfterSs();
+        parent = merge_1.SnapshotUtil.combineSnapshots(this.getGrp().DATA_INSERT_EVENT(), partition, parent).getAfterSs();
+        parent = merge_1.SnapshotUtil.combineSnapshots(this.getGrp().DATA_INSERT_ODD(), partition, parent).getAfterSs();
+        ttlRestore.setRestoredSs(partition);
+        ttlRestore.setRemainingSs(parent);
+        this.expiredMatches.remove(key);
+        return ttlRestore;
+    }
+    clearBin(key) {
+        this.expiredMatches.remove(key);
+        this.ttlStatus.remove(key);
+    }
+    containData(key) {
+        return this.expiredMatches.containsKey(key);
+    }
+    getTtlConfig() {
+        return this.ttlConfig;
+    }
+    getFsRepo() {
+        return this.fsRepo;
+    }
+    getTtlRestoreSnapshot(incoming) {
+        let restoreSnapshot = null;
+        if (this.ttlStatus.isEmpty()) {
+            return restoreSnapshot;
+        }
+        if (this.getGrp().DATA_RESET().id() == incoming.msgType().id()) {
+            incoming.data().getPartitions().forEach(pKey => {
+                console.log("Dropping partition " + pKey);
+                this.expiredMatches.remove(pKey);
+            });
+        }
+        else {
+            incoming.data().getPartitionMap().forEach((pKey, val) => {
+                let restoreKeys = [];
+                if (this.ttlStatus.contains(pKey)) {
+                    this.ttlStatus.remove(pKey);
+                    restoreKeys.push(pKey);
+                }
+                if (restoreKeys.length > 0) {
+                    restoreSnapshot = new TTLRestoreCheck(this, restoreKeys, incoming.stream());
+                }
+            });
+        }
+        return restoreSnapshot;
+    }
+    getTtlRemoveSnapshot() {
+        let ttlSnapshots = this.getFsRepo().getTtlRemoveSnapshot();
+        ttlSnapshots.forEach(removeSnapshot => {
+            removeSnapshot.setRecycleBin(this);
+            removeSnapshot.getKeys().forEach(partitionKey => {
+                this.ttlStatus.add(partitionKey);
+            });
+        });
+        return ttlSnapshots;
+    }
+    /**
+     * Copies the data in this RecycleBin related to the given PartitionKey into the
+     * list of matches.
+     *
+     * @param key
+     * @param matches
+     */
+    copyData(key, matches) {
+        let snapshot = this.expiredMatches.getValue(key);
+        if (snapshot === undefined) {
+            return matches;
+        }
+        let parent = new data_structure_1.IndexedSnapshotImpl(matches);
+        parent = merge_1.SnapshotUtil.combineSnapshots(this.getGrp().DATA_INSERT_MATCH(), snapshot, parent).getAfterSs();
+        parent = merge_1.SnapshotUtil.combineSnapshots(this.getGrp().DATA_INSERT_EVENT(), snapshot, parent).getAfterSs();
+        parent = merge_1.SnapshotUtil.combineSnapshots(this.getGrp().DATA_INSERT_ODD(), snapshot, parent).getAfterSs();
+        return parent.matchesSport;
+    }
+    getGrp() {
+        return this.grp;
+    }
+};
+RecycleBin = __decorate([
+    (0, injection_js_1.Injectable)(),
+    __metadata("design:paramtypes", [TTLConfig, message_class_1.SportsFeedMessageGroup, AbstractFSRepo])
+], RecycleBin);
+exports.RecycleBin = RecycleBin;

package/lib/data_structure.d.ts

@@ -0,0 +1,113 @@
+import * as Collections from 'typescript-collections';
+import { IMessageClass } from "@jayesol/jayeson.lib.delivery";
+import { ISnapshot, Snapshot, PartitionKey, IBetMatch } from "@jayesol/jayeson.lib.record";
+export declare class Incoming {
+    private _msgType;
+    private _stream;
+    private _data;
+    constructor(_msgType: IMessageClass, _stream: string, _data: IndexedSnapshot);
+    msgType(): IMessageClass;
+    stream(): string;
+    data(): IndexedSnapshot;
+}
+export interface IndexedSnapshot extends ISnapshot<IBetMatch> {
+    getPartitions(): Collections.Set<PartitionKey>;
+    getPartitionMap(): Collections.Dictionary<PartitionKey, number>;
+}
+export declare class IndexedSnapshotImpl extends Snapshot<IBetMatch> implements IndexedSnapshot {
+    private partitions;
+    static EMPTY_SNAPSHOT: IndexedSnapshotImpl;
+    constructor(matches?: {
+        [sport: number]: IBetMatch[];
+    }, partitions?: Collections.Dictionary<PartitionKey, number>);
+    getPartitions(): Collections.Set<PartitionKey>;
+    getPartitionMap(): Collections.Dictionary<PartitionKey, number>;
+}
+export interface Outgoing {
+    msgType(): IMessageClass;
+}
+export interface DeltaOutgoing extends Outgoing {
+    /**
+     * Indexed snapshot after Merge
+     */
+    after(): IndexedSnapshot;
+    /**
+     * Contents of this Delta
+     */
+    delta(): IndexedSnapshot;
+    /**
+     * Indexed Snapshot before Merge
+     */
+    before(): IndexedSnapshot;
+}
+export declare class OutgoingImpl implements Outgoing {
+    private _msgType;
+    private _msg;
+    constructor(_msgType: IMessageClass, _msg: any);
+    msgType(): IMessageClass;
+    msg(): any;
+}
+export declare class DeltaOutgoingImpl extends OutgoingImpl implements DeltaOutgoing {
+    private _delta;
+    private _after?;
+    private _before?;
+    constructor(_msgType: IMessageClass, _delta: IndexedSnapshot, _after?: IndexedSnapshot, _before?: IndexedSnapshot);
+    after(): IndexedSnapshot;
+    delta(): IndexedSnapshot;
+    before(): IndexedSnapshot;
+}
+export declare class MessageBeforeTransform {
+    private transformEvent;
+    private insertEvent;
+    private deleteEvent;
+    private suppressMatch;
+    private insertMatch;
+    private deleteMatch;
+    private afterSs;
+    private beforeSs;
+    constructor();
+    getTransformEvent(): string[];
+    setTransformEvent(eventId: string): void;
+    getSuppressMatch(): string[];
+    setSuppressMatch(matchId: string): void;
+    setAfterSs(afterSs: IndexedSnapshot): void;
+    getAfterSs(): IndexedSnapshot;
+    setBeforeSs(beforeSs: IndexedSnapshot): void;
+    getBeforeSs(): IndexedSnapshot;
+    setInsertEvent(eventId: string): void;
+    getInsertEvent(): string[];
+    setDeleteEvent(eventId: string): void;
+    getDeleteEvent(): string[];
+    setInsertMatch(matchId: string): void;
+    getInsertMatch(): string[];
+    setDeleteMatch(matchId: string): void;
+    getDeleteMatch(): string[];
+}
+export declare enum ConvertedMsg {
+    INSERT_EVENT_TO_UPDATE = 0,
+    DELETE_EVENT_TO_UPDATE = 1,
+    INSERT_MATCH_SUPPRESS = 2,
+    DELETE_MATCH_SUPPRESS = 3,
+    ORIGINAL = 4
+}
+export declare class MergeableWrapper {
+    private deltaOut;
+    private snap;
+    constructor();
+    setDeltaOut(out: DeltaOutgoing[]): void;
+    setAfter(after: IndexedSnapshot): void;
+    getDeltaOut(): DeltaOutgoing[];
+    getAfter(): IndexedSnapshot;
+}
+export declare class TTLWrapper {
+    private removedSs;
+    private remainingSs;
+    private restoredSs;
+    _RemovedKey(): void;
+    setRemovedSs(remove: IndexedSnapshot): void;
+    getRemovedSs(): IndexedSnapshot;
+    setRemainingSs(remain: IndexedSnapshot): void;
+    getRemainingSs(): IndexedSnapshot;
+    getRestoredSs(): IndexedSnapshot;
+    setRestoredSs(restore: IndexedSnapshot): void;
+}