@jayesol/jayeson.lib.sports 2.2.7-beta → 2.2.7-beta2

package/lib/message_class.d.ts

@@ -0,0 +1,152 @@
+import deliver = require('@jayesol/jayeson.lib.delivery');
+import { PartitionKey, SportType, IBetMatch } from '@jayesol/jayeson.lib.record';
+import * as proto from './protobuf_bundle';
+import * as Collections from 'typescript-collections';
+import { ICodec } from './codec';
+export declare abstract class AbstractMessageClass extends deliver.IMessageClass {
+    private _msgGroup;
+    private _id;
+    private _instanceClass;
+    private _sportCodecs;
+    private _partitionCodec;
+    constructor(_msgGroup: deliver.IMessageGroup, _id: number, _instanceClass: any, _sportCodecs: SportsCodecs, _partitionCodec: PartitionCodec);
+    id(): number;
+    SportsFeedMessageGroup(): deliver.IMessageGroup;
+    instanceClass(): any;
+    sportCodecs(): SportsCodecs;
+    partitionCodec(): PartitionCodec;
+    abstract read(msg: proto.DataMessage, codec: ICodec, pool: string[], key: PartitionKey): IBetMatch[];
+    private unpack;
+    inHandlers(): deliver.MsgHandler[];
+    outHandlers(): deliver.MsgHandler[];
+    private asSportType;
+}
+export declare class FilterMessageClass extends deliver.JSonMessageClass {
+    constructor(msgGroup: deliver.IMessageGroup, id: number);
+}
+export declare class SportsCodecs {
+    readonly sportsMappings: Collections.Dictionary<SportType, ICodec>;
+    constructor(sportsMappings?: Collections.Dictionary<SportType, ICodec>);
+    getCodec(sportType: SportType): ICodec;
+}
+export declare class PartitionCodec {
+    decode(key: proto.PartitionKey, pool: string[]): PartitionKey;
+}
+export declare class InsertMatchMessageClass extends AbstractMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number, sportCodec: SportsCodecs, partitionCodec: PartitionCodec);
+    read(msg: proto.DataMessage, codec: ICodec, pool: string[], key: PartitionKey): IBetMatch[];
+}
+export declare class InsertEventMessageClass extends AbstractMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number, sportCodec: SportsCodecs, partitionCodec: PartitionCodec);
+    read(msg: proto.DataMessage, codec: ICodec, pool: string[], key: PartitionKey): IBetMatch[];
+}
+export declare class InsertOddMessageClass extends AbstractMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number, sportCodec: SportsCodecs, partitionCodec: PartitionCodec);
+    read(msg: proto.DataMessage, codec: ICodec, pool: string[], key: PartitionKey): IBetMatch[];
+}
+export declare class UpdateMatchMessageClass extends AbstractMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number, sportCodec: SportsCodecs, partitionCodec: PartitionCodec);
+    read(msg: proto.DataMessage, codec: ICodec, pool: string[], key: PartitionKey): IBetMatch[];
+}
+export declare class UpdateEventMessageClass extends AbstractMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number, sportCodec: SportsCodecs, partitionCodec: PartitionCodec);
+    read(msg: proto.DataMessage, codec: ICodec, pool: string[], key: PartitionKey): IBetMatch[];
+}
+export declare class UpdateOddMessageClass extends AbstractMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number, sportCodec: SportsCodecs, partitionCodec: PartitionCodec);
+    read(msg: proto.DataMessage, codec: ICodec, pool: string[], key: PartitionKey): IBetMatch[];
+}
+export declare class DeleteMatchMessageClass extends AbstractMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number, sportCodec: SportsCodecs, partitionCodec: PartitionCodec);
+    read(msg: proto.DataMessage, codec: ICodec, pool: string[], key: PartitionKey): IBetMatch[];
+}
+export declare class DeleteEventMessageClass extends AbstractMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number, sportCodec: SportsCodecs, partitionCodec: PartitionCodec);
+    read(msg: proto.DataMessage, codec: ICodec, pool: string[], key: PartitionKey): IBetMatch[];
+}
+export declare class DeleteOddMessageClass extends AbstractMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number, sportCodec: SportsCodecs, partitionCodec: PartitionCodec);
+    read(msg: proto.DataMessage, codec: ICodec, pool: string[], key: PartitionKey): IBetMatch[];
+}
+export declare class ResetMessageClass extends AbstractMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number, sportCodec: SportsCodecs, partitionCodec: PartitionCodec);
+    read(msg: proto.DataMessage, codec: ICodec, pool: string[], key: PartitionKey): IBetMatch[];
+}
+export declare class TTLRemoveMessageClass extends AbstractMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number, sportCodec: SportsCodecs, partitionCodec: PartitionCodec);
+    read(msg: proto.DataMessage, codec: ICodec, pool: string[], key: PartitionKey): IBetMatch[];
+}
+export declare class TTLRestoreMessageClass extends AbstractMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number, sportCodec: SportsCodecs, partitionCodec: PartitionCodec);
+    read(msg: proto.DataMessage, codec: ICodec, pool: string[], key: PartitionKey): IBetMatch[];
+}
+export declare class SwitchFilterStartMessageClass extends deliver.EmptyMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number);
+}
+export declare class SwitchFilterEndMessageClass extends deliver.EmptyMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number);
+}
+export declare class SwitchFilterFailMessageClass extends deliver.EmptyMessageClass {
+    constructor(group: deliver.IMessageGroup, id: number);
+}
+export declare class StartSubscribeFeed {
+    exclude: string[];
+    wireFormat: string;
+    constructor(exclude: string[], wireFormat: string);
+}
+export declare class RefreshMessageClass extends deliver.JSonMessageClass {
+    constructor(msgGroup: deliver.IMessageGroup, id: number);
+    inHandlers(): deliver.MsgHandler[];
+    private unpack;
+}
+export declare class SportsFeedMessageGroup extends deliver.IMessageGroup {
+    private _DATA_RESET;
+    private _DATA_INSERT_ODD;
+    private _DATA_UPDATE_ODD;
+    private _DATA_DELETE_ODD;
+    private _DATA_INSERT_EVENT;
+    private _DATA_UPDATE_EVENT;
+    private _DATA_DELETE_EVENT;
+    private _DATA_INSERT_MATCH;
+    private _DATA_UPDATE_MATCH;
+    private _DATA_DELETE_MATCH;
+    private _TTL_RESTORE;
+    private _TTL_REMOVE;
+    private _FILTER_REMOVE;
+    private _FILTER_SET;
+    private _ADMIN_START_SUBSCRIBE_FEED;
+    private _ADMIN_REFRESH;
+    private _SWITCH_FILTER_START;
+    private _SWITCH_FILTER_END;
+    private _FULLSNAPSHOT_START;
+    private _FULLSNAPSHOT_END;
+    private _SWITCH_FILTER_FAIL;
+    private _TTL_RESTORE_START;
+    private _TTL_RESTORE_END;
+    DATA_RESET(): ResetMessageClass;
+    DATA_INSERT_ODD(): InsertOddMessageClass;
+    DATA_UPDATE_ODD(): UpdateOddMessageClass;
+    DATA_DELETE_ODD(): DeleteOddMessageClass;
+    DATA_INSERT_EVENT(): InsertEventMessageClass;
+    DATA_UPDATE_EVENT(): UpdateEventMessageClass;
+    DATA_DELETE_EVENT(): DeleteEventMessageClass;
+    TTL_REMOVE(): TTLRemoveMessageClass;
+    TTL_RESTORE(): TTLRestoreMessageClass;
+    TTL_RESTORE_START(): TTLRestoreMessageClass;
+    TTL_RESTORE_END(): deliver.EmptyMessageClass;
+    DATA_INSERT_MATCH(): InsertMatchMessageClass;
+    DATA_UPDATE_MATCH(): UpdateMatchMessageClass;
+    DATA_DELETE_MATCH(): DeleteMatchMessageClass;
+    FILTER_REMOVE(): deliver.StringMessageClass;
+    FILTER_SET(): FilterMessageClass;
+    ADMIN_START_SUBSCRIBE_FEED(): deliver.JSonMessageClass;
+    ADMIN_REFRESH(): RefreshMessageClass;
+    SWITCH_FILTER_START(): deliver.StringMessageClass;
+    SWITCH_FILTER_END(): deliver.EmptyMessageClass;
+    FULLSNAPSHOT_START(): deliver.EmptyMessageClass;
+    FULLSNAPSHOT_END(): deliver.EmptyMessageClass;
+    SWITCH_FILTER_FAIL(): deliver.StringMessageClass;
+    isIndicatorMessage(messageClass: deliver.IMessageClass): boolean;
+    isSwitchFilterStatusMsg(messageClass: deliver.IMessageClass): boolean;
+    constructor(sportCodec?: SportsCodecs, partitionCodec?: PartitionCodec);
+}

package/lib/message_class.js

@@ -0,0 +1,466 @@
+"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 __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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SportsFeedMessageGroup = exports.RefreshMessageClass = exports.StartSubscribeFeed = exports.SwitchFilterFailMessageClass = exports.SwitchFilterEndMessageClass = exports.SwitchFilterStartMessageClass = exports.TTLRestoreMessageClass = exports.TTLRemoveMessageClass = exports.ResetMessageClass = exports.DeleteOddMessageClass = exports.DeleteEventMessageClass = exports.DeleteMatchMessageClass = exports.UpdateOddMessageClass = exports.UpdateEventMessageClass = exports.UpdateMatchMessageClass = exports.InsertOddMessageClass = exports.InsertEventMessageClass = exports.InsertMatchMessageClass = exports.PartitionCodec = exports.SportsCodecs = exports.FilterMessageClass = exports.AbstractMessageClass = void 0;
+const deliver = require("@jayesol/jayeson.lib.delivery");
+const jayeson_lib_record_1 = require("@jayesol/jayeson.lib.record");
+const data_structure_1 = require("./data_structure");
+const proto = __importStar(require("./protobuf_bundle"));
+const Collections = __importStar(require("typescript-collections"));
+const codec_1 = require("./codec");
+const soccer_codec_1 = require("./soccer_codec");
+const basketball_codec_1 = require("./basketball_codec");
+const tennis_codec_1 = require("./tennis_codec");
+class AbstractMessageClass extends deliver.IMessageClass {
+    constructor(_msgGroup, _id, _instanceClass, _sportCodecs, _partitionCodec) {
+        super(_msgGroup, _id, _instanceClass);
+        this._msgGroup = _msgGroup;
+        this._id = _id;
+        this._instanceClass = _instanceClass;
+        this._sportCodecs = _sportCodecs;
+        this._partitionCodec = _partitionCodec;
+        this.unpack = (wrapper) => {
+            let input = proto.DataMessage.decode(wrapper.message);
+            wrapper.message = new data_structure_1.IndexedSnapshotImpl({});
+            let pool = input.stringPool;
+            let pbufKey = input.feedKey;
+            //pbuf key?
+            if (pbufKey === undefined) {
+                return;
+            }
+            let sport = this.asSportType(pbufKey.sport);
+            if (sport === null || sport === undefined) {
+                return;
+            }
+            let codec = this._sportCodecs.getCodec(sport);
+            if (codec === null || codec === undefined) {
+                return;
+            }
+            let key = this._partitionCodec.decode(new proto.PartitionKey(pbufKey), pool);
+            let matches = this.read(input, codec, pool, key);
+            let sportDelta = {};
+            sportDelta[sport] = matches;
+            let partitionsMap = new Collections.Dictionary();
+            partitionsMap.setValue(key, new Date().getTime());
+            wrapper.message = new data_structure_1.IndexedSnapshotImpl(sportDelta, partitionsMap);
+        };
+    }
+    id() {
+        return this._id;
+    }
+    SportsFeedMessageGroup() {
+        return this._msgGroup;
+    }
+    instanceClass() {
+        return this._instanceClass;
+    }
+    sportCodecs() {
+        return this._sportCodecs;
+    }
+    partitionCodec() {
+        return this._partitionCodec;
+    }
+    inHandlers() {
+        return [{ unpack: this.unpack }];
+    }
+    outHandlers() {
+        return [];
+    }
+    asSportType(pbuf) {
+        let sportName = proto.SportType[pbuf];
+        return jayeson_lib_record_1.SportType[sportName];
+    }
+}
+exports.AbstractMessageClass = AbstractMessageClass;
+class FilterMessageClass extends deliver.JSonMessageClass {
+    constructor(msgGroup, id) {
+        super(msgGroup, id, codec_1.FilterRequest);
+    }
+}
+exports.FilterMessageClass = FilterMessageClass;
+class SportsCodecs {
+    constructor(sportsMappings = undefined) {
+        this.sportsMappings = sportsMappings;
+        if (sportsMappings === undefined) {
+            this.sportsMappings = new Collections.Dictionary();
+            this.sportsMappings.setValue(jayeson_lib_record_1.SportType.SOCCER, new soccer_codec_1.SoccerCodec());
+            this.sportsMappings.setValue(jayeson_lib_record_1.SportType.TENNIS, new tennis_codec_1.TennisCodec());
+            this.sportsMappings.setValue(jayeson_lib_record_1.SportType.BASKETBALL, new basketball_codec_1.BasketballCodec());
+        }
+    }
+    getCodec(sportType) {
+        return this.sportsMappings.getValue(sportType);
+    }
+}
+exports.SportsCodecs = SportsCodecs;
+class PartitionCodec {
+    decode(key, pool) {
+        let type = jayeson_lib_record_1.OddType.LIVE;
+        switch (key.oddType) {
+            case proto.OddType.LIVE:
+                type = jayeson_lib_record_1.OddType.LIVE;
+                break;
+            case proto.OddType.TODAY:
+                type = jayeson_lib_record_1.OddType.TODAY;
+                break;
+            case proto.OddType.EARLY:
+                type = jayeson_lib_record_1.OddType.EARLY;
+                break;
+        }
+        let sporttype = jayeson_lib_record_1.SportType.SOCCER;
+        switch (key.sport) {
+            case proto.SportType.SOCCER:
+                sporttype = jayeson_lib_record_1.SportType.SOCCER;
+                break;
+            case proto.SportType.BASKETBALL:
+                sporttype = jayeson_lib_record_1.SportType.BASKETBALL;
+                break;
+            case proto.SportType.HOCKEY:
+                sporttype = jayeson_lib_record_1.SportType.HOCKEY;
+                break;
+            case proto.SportType.TENNIS:
+                sporttype = jayeson_lib_record_1.SportType.TENNIS;
+                break;
+            case proto.SportType.HORSE_RACING:
+                sporttype = jayeson_lib_record_1.SportType.HORSE_RACING;
+                break;
+            case proto.SportType.MOTOR_SPORT:
+                sporttype = jayeson_lib_record_1.SportType.MOTOR_SPORT;
+                break;
+            case proto.SportType.HANDBALL:
+                sporttype = jayeson_lib_record_1.SportType.HANDBALL;
+                break;
+            case proto.SportType.CRICKET:
+                sporttype = jayeson_lib_record_1.SportType.CRICKET;
+                break;
+            case proto.SportType.POOL:
+                sporttype = jayeson_lib_record_1.SportType.POOL;
+                break;
+        }
+        return new jayeson_lib_record_1.PartitionKey(pool[key.source], type, sporttype);
+    }
+}
+exports.PartitionCodec = PartitionCodec;
+class InsertMatchMessageClass extends AbstractMessageClass {
+    constructor(group, id, sportCodec, partitionCodec) {
+        super(group, id, data_structure_1.IndexedSnapshotImpl, sportCodec, partitionCodec);
+    }
+    read(msg, codec, pool, key) {
+        let matches = msg.matches.matches.map(o => new proto.BaseMatch(o));
+        return codec.decodeMatch(matches, pool, codec_1.EncodeAction.INSERT, key);
+    }
+}
+exports.InsertMatchMessageClass = InsertMatchMessageClass;
+class InsertEventMessageClass extends AbstractMessageClass {
+    constructor(group, id, sportCodec, partitionCodec) {
+        super(group, id, data_structure_1.IndexedSnapshotImpl, sportCodec, partitionCodec);
+    }
+    read(msg, codec, pool, key) {
+        let events = msg.events.events.map(o => new proto.BaseEvent(o));
+        return codec.decodeEvent(events, pool, codec_1.EncodeAction.INSERT, key);
+    }
+}
+exports.InsertEventMessageClass = InsertEventMessageClass;
+class InsertOddMessageClass extends AbstractMessageClass {
+    constructor(group, id, sportCodec, partitionCodec) {
+        super(group, id, data_structure_1.IndexedSnapshotImpl, sportCodec, partitionCodec);
+    }
+    read(msg, codec, pool, key) {
+        let odds = msg.odds.odds.map(o => new proto.BaseRecord(o));
+        return codec.decodeRecord(odds, pool, codec_1.EncodeAction.INSERT, key);
+    }
+}
+exports.InsertOddMessageClass = InsertOddMessageClass;
+class UpdateMatchMessageClass extends AbstractMessageClass {
+    constructor(group, id, sportCodec, partitionCodec) {
+        super(group, id, data_structure_1.IndexedSnapshotImpl, sportCodec, partitionCodec);
+    }
+    read(msg, codec, pool, key) {
+        let matches = msg.matches.matches.map(o => new proto.BaseMatch(o));
+        return codec.decodeMatch(matches, pool, codec_1.EncodeAction.UPDATE, key);
+    }
+}
+exports.UpdateMatchMessageClass = UpdateMatchMessageClass;
+class UpdateEventMessageClass extends AbstractMessageClass {
+    constructor(group, id, sportCodec, partitionCodec) {
+        super(group, id, data_structure_1.IndexedSnapshotImpl, sportCodec, partitionCodec);
+    }
+    read(msg, codec, pool, key) {
+        let events = msg.events.events.map(o => new proto.BaseEvent(o));
+        return codec.decodeEvent(events, pool, codec_1.EncodeAction.UPDATE, key);
+    }
+}
+exports.UpdateEventMessageClass = UpdateEventMessageClass;
+class UpdateOddMessageClass extends AbstractMessageClass {
+    constructor(group, id, sportCodec, partitionCodec) {
+        super(group, id, data_structure_1.IndexedSnapshotImpl, sportCodec, partitionCodec);
+    }
+    read(msg, codec, pool, key) {
+        let odds = msg.odds.odds.map(o => new proto.BaseRecord(o));
+        return codec.decodeRecord(odds, pool, codec_1.EncodeAction.UPDATE, key);
+    }
+}
+exports.UpdateOddMessageClass = UpdateOddMessageClass;
+class DeleteMatchMessageClass extends AbstractMessageClass {
+    constructor(group, id, sportCodec, partitionCodec) {
+        super(group, id, data_structure_1.IndexedSnapshotImpl, sportCodec, partitionCodec);
+    }
+    read(msg, codec, pool, key) {
+        let matches = msg.matches.matches.map(o => new proto.BaseMatch(o));
+        return codec.decodeMatch(matches, pool, codec_1.EncodeAction.DELETE, key);
+    }
+}
+exports.DeleteMatchMessageClass = DeleteMatchMessageClass;
+class DeleteEventMessageClass extends AbstractMessageClass {
+    constructor(group, id, sportCodec, partitionCodec) {
+        super(group, id, data_structure_1.IndexedSnapshotImpl, sportCodec, partitionCodec);
+    }
+    read(msg, codec, pool, key) {
+        let events = msg.events.events.map(o => new proto.BaseEvent(o));
+        return codec.decodeEvent(events, pool, codec_1.EncodeAction.DELETE, key);
+    }
+}
+exports.DeleteEventMessageClass = DeleteEventMessageClass;
+class DeleteOddMessageClass extends AbstractMessageClass {
+    constructor(group, id, sportCodec, partitionCodec) {
+        super(group, id, data_structure_1.IndexedSnapshotImpl, sportCodec, partitionCodec);
+    }
+    read(msg, codec, pool, key) {
+        let odds = msg.odds.odds.map(o => new proto.BaseRecord(o));
+        return codec.decodeRecord(odds, pool, codec_1.EncodeAction.DELETE, key);
+    }
+}
+exports.DeleteOddMessageClass = DeleteOddMessageClass;
+class ResetMessageClass extends AbstractMessageClass {
+    constructor(group, id, sportCodec, partitionCodec) {
+        super(group, id, data_structure_1.IndexedSnapshotImpl, sportCodec, partitionCodec);
+    }
+    read(msg, codec, pool, key) {
+        return [];
+    }
+}
+exports.ResetMessageClass = ResetMessageClass;
+class TTLRemoveMessageClass extends AbstractMessageClass {
+    constructor(group, id, sportCodec, partitionCodec) {
+        super(group, id, data_structure_1.IndexedSnapshotImpl, sportCodec, partitionCodec);
+    }
+    read(msg, codec, pool, key) {
+        return [];
+    }
+}
+exports.TTLRemoveMessageClass = TTLRemoveMessageClass;
+class TTLRestoreMessageClass extends AbstractMessageClass {
+    constructor(group, id, sportCodec, partitionCodec) {
+        super(group, id, data_structure_1.IndexedSnapshotImpl, sportCodec, partitionCodec);
+    }
+    read(msg, codec, pool, key) {
+        return [];
+    }
+}
+exports.TTLRestoreMessageClass = TTLRestoreMessageClass;
+class SwitchFilterStartMessageClass extends deliver.EmptyMessageClass {
+    constructor(group, id) {
+        super(group, id);
+    }
+}
+exports.SwitchFilterStartMessageClass = SwitchFilterStartMessageClass;
+class SwitchFilterEndMessageClass extends deliver.EmptyMessageClass {
+    constructor(group, id) {
+        super(group, id);
+    }
+}
+exports.SwitchFilterEndMessageClass = SwitchFilterEndMessageClass;
+class SwitchFilterFailMessageClass extends deliver.EmptyMessageClass {
+    constructor(group, id) {
+        super(group, id);
+    }
+}
+exports.SwitchFilterFailMessageClass = SwitchFilterFailMessageClass;
+class StartSubscribeFeed {
+    constructor(exclude, wireFormat) {
+        this.exclude = exclude;
+        this.wireFormat = wireFormat;
+    }
+}
+exports.StartSubscribeFeed = StartSubscribeFeed;
+class RefreshMessage {
+}
+class RefreshMessageClass extends deliver.JSonMessageClass {
+    constructor(msgGroup, id) {
+        super(msgGroup, id, RefreshMessage);
+        this.unpack = (wrapper) => {
+            let refreshMsg = wrapper.message;
+            let newPartitions = new Collections.Dictionary();
+            refreshMsg.partitionKeys.forEach(key => {
+                newPartitions.setValue(jayeson_lib_record_1.PartitionKey.fromString(key), new Date().getTime());
+            });
+            wrapper.message = new data_structure_1.IndexedSnapshotImpl({}, newPartitions);
+        };
+    }
+    inHandlers() {
+        return super.inHandlers().concat([{ unpack: this.unpack }]);
+    }
+}
+exports.RefreshMessageClass = RefreshMessageClass;
+class SportsFeedMessageGroup extends deliver.IMessageGroup {
+    DATA_RESET() {
+        return this._DATA_RESET;
+    }
+    DATA_INSERT_ODD() {
+        return this._DATA_INSERT_ODD;
+    }
+    DATA_UPDATE_ODD() {
+        return this._DATA_UPDATE_ODD;
+    }
+    DATA_DELETE_ODD() {
+        return this._DATA_DELETE_ODD;
+    }
+    DATA_INSERT_EVENT() {
+        return this._DATA_INSERT_EVENT;
+    }
+    DATA_UPDATE_EVENT() {
+        return this._DATA_UPDATE_EVENT;
+    }
+    DATA_DELETE_EVENT() {
+        return this._DATA_DELETE_EVENT;
+    }
+    TTL_REMOVE() {
+        return this._TTL_REMOVE;
+    }
+    TTL_RESTORE() {
+        return this._TTL_RESTORE;
+    }
+    TTL_RESTORE_START() {
+        return this._TTL_RESTORE_START;
+    }
+    TTL_RESTORE_END() {
+        return this._TTL_RESTORE_END;
+    }
+    DATA_INSERT_MATCH() {
+        return this._DATA_INSERT_MATCH;
+    }
+    DATA_UPDATE_MATCH() {
+        return this._DATA_UPDATE_MATCH;
+    }
+    DATA_DELETE_MATCH() {
+        return this._DATA_DELETE_MATCH;
+    }
+    FILTER_REMOVE() {
+        return this._FILTER_REMOVE;
+    }
+    FILTER_SET() {
+        return this._FILTER_SET;
+    }
+    ADMIN_START_SUBSCRIBE_FEED() {
+        return this._ADMIN_START_SUBSCRIBE_FEED;
+    }
+    ADMIN_REFRESH() {
+        return this._ADMIN_REFRESH;
+    }
+    SWITCH_FILTER_START() {
+        return this._SWITCH_FILTER_START;
+    }
+    SWITCH_FILTER_END() {
+        return this._SWITCH_FILTER_END;
+    }
+    FULLSNAPSHOT_START() {
+        return this._FULLSNAPSHOT_START;
+    }
+    FULLSNAPSHOT_END() {
+        return this._FULLSNAPSHOT_END;
+    }
+    SWITCH_FILTER_FAIL() {
+        return this._SWITCH_FILTER_FAIL;
+    }
+    isIndicatorMessage(messageClass) {
+        return messageClass == this.SWITCH_FILTER_START() ||
+            messageClass == this.SWITCH_FILTER_END() ||
+            messageClass == this.FULLSNAPSHOT_START() ||
+            messageClass == this.FULLSNAPSHOT_END() ||
+            messageClass == this.SWITCH_FILTER_FAIL() ||
+            messageClass == this.TTL_RESTORE_START() ||
+            messageClass == this.TTL_RESTORE_END();
+    }
+    isSwitchFilterStatusMsg(messageClass) {
+        return messageClass == this.SWITCH_FILTER_START() ||
+            messageClass == this.SWITCH_FILTER_FAIL();
+    }
+    constructor(sportCodec = new SportsCodecs(), partitionCodec = new PartitionCodec()) {
+        super(70);
+        // Initialize message classes
+        this._DATA_RESET = new ResetMessageClass(this, 0, sportCodec, partitionCodec);
+        this._DATA_INSERT_ODD = new InsertOddMessageClass(this, 1, sportCodec, partitionCodec);
+        this._DATA_UPDATE_ODD = new UpdateOddMessageClass(this, 2, sportCodec, partitionCodec);
+        this._DATA_DELETE_ODD = new DeleteOddMessageClass(this, 3, sportCodec, partitionCodec);
+        this._DATA_INSERT_EVENT = new InsertEventMessageClass(this, 4, sportCodec, partitionCodec);
+        this._DATA_UPDATE_EVENT = new UpdateEventMessageClass(this, 5, sportCodec, partitionCodec);
+        this._DATA_DELETE_EVENT = new DeleteEventMessageClass(this, 6, sportCodec, partitionCodec);
+        this._DATA_INSERT_MATCH = new InsertMatchMessageClass(this, 7, sportCodec, partitionCodec);
+        this._DATA_UPDATE_MATCH = new UpdateMatchMessageClass(this, 8, sportCodec, partitionCodec);
+        this._DATA_DELETE_MATCH = new DeleteMatchMessageClass(this, 9, sportCodec, partitionCodec);
+        this._TTL_RESTORE = new TTLRestoreMessageClass(this, 10, sportCodec, partitionCodec);
+        this._TTL_REMOVE = new TTLRestoreMessageClass(this, 11, sportCodec, partitionCodec);
+        this._FILTER_REMOVE = new deliver.StringMessageClass(this, 13);
+        this._FILTER_SET = new FilterMessageClass(this, 14);
+        this._ADMIN_START_SUBSCRIBE_FEED = new deliver.JSonMessageClass(this, 16, StartSubscribeFeed);
+        this._ADMIN_REFRESH = new RefreshMessageClass(this, 17);
+        this._SWITCH_FILTER_START = new deliver.StringMessageClass(this, 18);
+        this._SWITCH_FILTER_END = new deliver.EmptyMessageClass(this, 19);
+        this._FULLSNAPSHOT_START = new deliver.EmptyMessageClass(this, 20);
+        this._FULLSNAPSHOT_END = new deliver.EmptyMessageClass(this, 21);
+        this._SWITCH_FILTER_FAIL = new deliver.StringMessageClass(this, 22);
+        this._TTL_RESTORE_START = new TTLRestoreMessageClass(this, 23, sportCodec, partitionCodec);
+        this._TTL_RESTORE_END = new deliver.EmptyMessageClass(this, 24);
+        // Index message class attributes
+        let classes = [this._DATA_RESET,
+            this._DATA_INSERT_ODD,
+            this._DATA_UPDATE_ODD,
+            this._DATA_DELETE_ODD,
+            this._DATA_INSERT_EVENT,
+            this._DATA_UPDATE_EVENT,
+            this._DATA_DELETE_EVENT,
+            this._DATA_INSERT_MATCH,
+            this._DATA_UPDATE_MATCH,
+            this._DATA_DELETE_MATCH,
+            this._TTL_RESTORE,
+            this._TTL_REMOVE,
+            this._FILTER_REMOVE,
+            this._FILTER_SET,
+            this._ADMIN_START_SUBSCRIBE_FEED,
+            this._ADMIN_REFRESH,
+            this._SWITCH_FILTER_START,
+            this._SWITCH_FILTER_END,
+            this._FULLSNAPSHOT_START,
+            this._FULLSNAPSHOT_END,
+            this._SWITCH_FILTER_FAIL,
+            this._TTL_RESTORE_START,
+            this._TTL_RESTORE_END
+        ];
+        classes.forEach(msgClass => {
+            this._classes[msgClass.id()] = msgClass;
+        });
+    }
+}
+exports.SportsFeedMessageGroup = SportsFeedMessageGroup;

package/lib/module.d.ts

@@ -0,0 +1,12 @@
+import * as D from '@jayesol/jayeson.lib.delivery';
+import { SportsFeedClient } from './client';
+export declare class SportsFeedCoreComponentModule {
+    static getBindingArray(exclude?: any[], wireFormat?: string, outputStreamName?: string): any[];
+}
+export declare class SportsFeedCoreService {
+    private client;
+    private subscriber;
+    constructor(streamFinder: string, feedScope: string);
+    getClient(): SportsFeedClient;
+    getSubscriber(): D.Subscriber;
+}