@xmobitea/gn-server 2.0.1

package/dist/GN-library/xconfig/lib/xConfig.d.ts

@@ -0,0 +1,14 @@
+import { xConfigItem } from "./entity/xConfigItem";
+import * as mongoDB from "mongodb";
+import { OnRunSuccess } from "./../../xbuilder/lib/OnRunSuccess";
+export declare class xConfig {
+    private configDic;
+    private configCollection;
+    setConfigCollection(configCollection: mongoDB.Collection<mongoDB.Document>): void;
+    run(onRunSuccess?: OnRunSuccess): void;
+    syncAllConfigAsync(): Promise<void>;
+    syncConfigFromDatabaseAsync(configName: string, label: string): Promise<xConfigItem>;
+    setConfigAsync(configName: string, label: string, data: {}): Promise<xConfigItem>;
+    getConfigItem(configName: string, label: string): xConfigItem;
+    getConfigDicViaLabel(label: string): Map<string, xConfigItem>;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/AvatarItem.d.ts

@@ -0,0 +1,4 @@
+export interface AvatarItem {
+    type: number;
+    value: string;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/BanItem.d.ts

@@ -0,0 +1,4 @@
+export interface BanItem {
+    tsExpire: number;
+    reason: string;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/CharacterItem.d.ts

@@ -0,0 +1,4 @@
+export interface CharacterItem {
+    characterId: string;
+    catalogId: string;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/CharacterPlayer.d.ts

@@ -0,0 +1,22 @@
+import * as mongoDB from "mongodb";
+import { GamePlayerBase } from "./GamePlayerBase";
+import { OwnerItem } from "./OwnerItem";
+import { RemoveStatusItem } from "./RemoveStatusItem";
+export declare class CharacterPlayer extends GamePlayerBase {
+    private static readonly _characterId;
+    private static readonly _catalogId;
+    private static readonly _owner;
+    private static readonly _removeStatus;
+    private readonly characterId;
+    private readonly catalogId;
+    private owner;
+    private removeStatus;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentCharacterPlayer;
+    getCharacterId(): string;
+    getCatalogId(): string;
+    getOwner(): OwnerItem;
+    setOwner(ownerId: string, ownerType: number): void;
+    getRemoveStatus(): RemoveStatusItem;
+    setRemoveStatus(tsRemove: number, reason?: string): void;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/ChatMessage.d.ts

@@ -0,0 +1,34 @@
+import * as mongoDB from "mongodb";
+import { MongoObject } from "./MongoObject";
+import { OwnerItem } from "./OwnerItem";
+import { RemoveStatusItem } from "./RemoveStatusItem";
+export declare class ChatMessage extends MongoObject {
+    private static readonly _messageId;
+    private static readonly _groupId;
+    private static readonly _sender;
+    private static readonly _message;
+    private static readonly _tsCreate;
+    private static readonly _tsLastUpdate;
+    private static readonly _removeStatus;
+    private readonly messageId;
+    private readonly groupId;
+    private sender;
+    private message;
+    private tsCreate;
+    private tsLastUpdate;
+    private removeStatus;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentChatMessage;
+    getMessageId(): string;
+    getGroupId(): string;
+    getSender(): OwnerItem;
+    setSender(senderId: string, senderType: number): void;
+    getMessage(): string;
+    setMessage(message: string): void;
+    getTsCreate(): number;
+    setTsCreate(tsCreate: number): void;
+    getTsLastUpdate(): number;
+    setTsLastUpdate(tsLastUpdate: number): void;
+    getRemoveStatus(): RemoveStatusItem;
+    setRemoveStatus(tsRemove: number, reason?: string): void;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/CurrencyItem.d.ts

@@ -0,0 +1,3 @@
+export interface CurrencyItem {
+    value: number;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/DataItem.d.ts

@@ -0,0 +1,5 @@
+import { DataValueType } from "./type/DataValueType";
+export interface DataItem {
+    key: string;
+    value: DataValueType;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/DataObjectBase.d.ts

@@ -0,0 +1,44 @@
+import * as mongoDB from "mongodb";
+import { AvatarItem } from "./AvatarItem";
+import { MongoObject } from "./MongoObject";
+import { DataValueType } from "./type/DataValueType";
+export declare class DataObjectBase extends MongoObject {
+    private static readonly _segments;
+    private static readonly _customDatas;
+    private static readonly _tsCreate;
+    private static readonly _displayName;
+    private static readonly _displayNameNormalize;
+    private static readonly _avatar;
+    private static readonly _tags;
+    static readonly DOT: string;
+    private segments;
+    private customDatas;
+    private displayName;
+    private avatar;
+    private tsCreate;
+    private tags;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentDataObjectBase;
+    getAllSegments(): Array<string>;
+    hasSegment(segment: string): boolean;
+    addSegment(segment: string): void;
+    removeSegment(segment: string): void;
+    removeAllSegments(): void;
+    getAllCustomDatas(): Map<string, DataValueType>;
+    hasCustomData(key: string): boolean;
+    getCustomData(key: string): DataValueType;
+    setCustomData(key: string, value: DataValueType): void;
+    removeCustomData(key: string): void;
+    getDisplayName(): string;
+    setDisplayName(displayName: string): void;
+    getAvatar(): AvatarItem;
+    setAvatar(type: number, value: string): void;
+    getTsCreate(): number;
+    setTsCreate(tsCreate: number): void;
+    getAllTags(): Map<string, string>;
+    clearTags(): void;
+    hasTag(key: string): boolean;
+    getTag(key: string): string;
+    setTag(key: string, value: string): void;
+    removeTag(key: string): void;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/ExternalItem.d.ts

@@ -0,0 +1,38 @@
+export interface ExternalItem {
+    device?: {
+        customDeviceId?: string;
+        androidDeviceId?: string;
+        iOSDeviceId?: string;
+        windowsPhoneDeviceId?: string;
+        windowsDeviceId?: string;
+        linuxDeviceId?: string;
+        macOSDeviceId?: string;
+        editorDeviceId?: string;
+    };
+    account?: {
+        username: string;
+        password: string;
+    };
+    custom?: {
+        customId: string;
+    };
+    apple?: {
+        appleId: string;
+        email: string;
+    };
+    google?: {
+        googleId: string;
+        displayName: string;
+        email: string;
+    };
+    facebook?: {
+        facebookId: string;
+        displayName: string;
+        email: string;
+    };
+    genericService?: {
+        genericServices: Map<string, {
+            serviceId: string;
+        }>;
+    };
+}

package/dist/GN-library/xdatabase/lib/entity/pro/FriendItem.d.ts

@@ -0,0 +1,6 @@
+export interface FriendItem {
+    friendId: string;
+    catalogId: string;
+    status: number;
+    tsLastStatusUpdate: number;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/GamePlayer.d.ts

@@ -0,0 +1,13 @@
+import * as mongoDB from "mongodb";
+import { GamePlayerBase } from "./GamePlayerBase";
+export declare class GamePlayer extends GamePlayerBase {
+    private static readonly _userId;
+    private static readonly _socketId;
+    private readonly userId;
+    private socketId;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentGamePlayer;
+    getUserId(): string;
+    getSocketId(): string;
+    setSocketId(socketId: string): void;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/GamePlayerBase.d.ts

@@ -0,0 +1,38 @@
+import * as mongoDB from "mongodb";
+import { PlayerBase } from "./PlayerBase";
+import { CharacterItem } from "./CharacterItem";
+import { InventoryItem } from "./InventoryItem";
+import { GroupItem } from "./GroupItem";
+import { FriendItem } from "./FriendItem";
+export declare class GamePlayerBase extends PlayerBase {
+    private static readonly _playerCharacters;
+    private static readonly _playerInventories;
+    private static readonly _playerGroups;
+    private static readonly _playerFriends;
+    private playerCharacters;
+    private playerInventories;
+    private playerGroups;
+    private playerFriends;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentGamePlayerBase;
+    getAllPlayerCharacters(): Array<CharacterItem>;
+    getPlayerCharacter(characterId: string): CharacterItem;
+    setPlayerCharacter(characterId: string, catalogId: string): void;
+    removePlayerCharacter(characterId: string): void;
+    hasPlayerCharacter(characterId: string): boolean;
+    getAllPlayerInventories(): Array<InventoryItem>;
+    getPlayerInventory(itemId: string): InventoryItem;
+    setPlayerInventory(itemId: string, catalogId: string, classId: string): void;
+    removePlayerInventory(itemId: string): void;
+    hasPlayerInventory(itemId: string): boolean;
+    getAllPlayerGroups(): Array<GroupItem>;
+    hasPlayerGroup(groupId: string): boolean;
+    getPlayerGroup(groupId: string): GroupItem;
+    setPlayerGroup(groupId: string, catalogId: string, status: number, tsLastStatusUpdate: number): void;
+    removePlayerGroup(groupId: string): void;
+    getAllPlayerFriends(): Array<FriendItem>;
+    hasPlayerFriend(friendId: string): boolean;
+    getPlayerFriend(friendId: string): FriendItem;
+    setPlayerFriend(friendId: string, catalogId: string, status: number, tsLastStatusUpdate: number): void;
+    removePlayerFriend(friendId: string): void;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/Group.d.ts

@@ -0,0 +1,61 @@
+import * as mongoDB from "mongodb";
+import { DataObjectBase } from "./DataObjectBase";
+import { MemberItem } from "./MemberItem";
+import { DataItem } from "./DataItem";
+import { CurrencyItem } from "./CurrencyItem";
+import { StatisticsItem } from "./StatisticsItem";
+import { InventoryItem } from "./InventoryItem";
+import { RemoveStatusItem } from "./RemoveStatusItem";
+import { DataValueType } from "./type/DataValueType";
+export declare class Group extends DataObjectBase {
+    private static readonly _groupId;
+    private static readonly _groupType;
+    private static readonly _catalogId;
+    private static readonly _members;
+    private static readonly _groupDatas;
+    private static readonly _groupCurrencies;
+    private static readonly _groupStatistics;
+    private static readonly _groupInventories;
+    private static readonly _removeStatus;
+    private readonly groupId;
+    private readonly groupType;
+    private readonly catalogId;
+    private members;
+    private groupCurrencies;
+    private groupStatistics;
+    private groupDatas;
+    private groupInventories;
+    private removeStatus;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentGroup;
+    getGroupId(): string;
+    getGroupType(): number;
+    getCatalogId(): string;
+    getAllMembers(): Array<MemberItem>;
+    hasMember(memberId: string): boolean;
+    getMember(memberId: string): MemberItem;
+    setMember(memberId: string, status: number): void;
+    removeMember(memberId: string): void;
+    getAllGroupCurrencies(): Map<string, CurrencyItem>;
+    hasGroupCurrency(key: string): boolean;
+    getGroupCurrency(key: string): CurrencyItem;
+    setGroupCurrency(key: string, value: number): void;
+    removeGroupCurrency(key: string): void;
+    getAllGroupDatas(): Array<DataItem>;
+    hasGroupData(key: string): boolean;
+    getGroupData(key: string): DataItem;
+    setGroupData(key: string, value: DataValueType): void;
+    removeItemData(key: string): void;
+    getAllGroupStatistics(): Map<string, StatisticsItem>;
+    hasGroupStatistics(key: string): boolean;
+    getGroupStatistics(key: string): StatisticsItem;
+    setGroupStatistics(key: string, value: number, tsLastUpdate: number): void;
+    removeGroupStatistics(key: string): void;
+    getAllGroupInventories(): Array<InventoryItem>;
+    hasGroupInventory(itemId: string): boolean;
+    getGroupInventory(itemId: string): InventoryItem;
+    setGroupInventory(itemId: string, catalogId: string, classId: string): void;
+    removeGroupInventory(itemId: string): void;
+    getRemoveStatus(): RemoveStatusItem;
+    setRemoveStatus(tsRemove: number, reason?: string): void;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/GroupItem.d.ts

@@ -0,0 +1,6 @@
+export interface GroupItem {
+    groupId: string;
+    catalogId: string;
+    status: number;
+    tsLastStatusUpdate: number;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/Inventory.d.ts

@@ -0,0 +1,49 @@
+import * as mongoDB from "mongodb";
+import { DataItem } from "./DataItem";
+import { DataObjectBase } from "./DataObjectBase";
+import { OwnerItem } from "./OwnerItem";
+import { RemoveStatusItem } from "./RemoveStatusItem";
+import { StatisticsItem } from "./StatisticsItem";
+import { DataValueType } from "./type/DataValueType";
+export declare class Inventory extends DataObjectBase {
+    private static readonly _amount;
+    private static readonly _itemId;
+    private static readonly _classId;
+    private static readonly _catalogId;
+    private static readonly _itemType;
+    private static readonly _owner;
+    private static readonly _itemDatas;
+    private static readonly _itemStatistics;
+    private static readonly _removeStatus;
+    private readonly itemId;
+    private readonly classId;
+    private readonly catalogId;
+    private readonly itemType;
+    private amount;
+    private owner;
+    private itemDatas;
+    private itemStatistics;
+    private removeStatus;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentInventory;
+    getItemId(): string;
+    getClassId(): string;
+    getCatalogId(): string;
+    getItemType(): number;
+    getAmount(): number;
+    setAmount(amount: number): void;
+    getOwner(): OwnerItem;
+    setOwner(ownerId: string, ownerType: number): void;
+    getAllItemDatas(): Array<DataItem>;
+    hasItemData(key: string): boolean;
+    getItemData(key: string): DataItem;
+    setItemData(key: string, value: DataValueType): void;
+    removeItemData(key: string): void;
+    getAllItemStatistics(): Map<string, StatisticsItem>;
+    hasItemStatistics(key: string): boolean;
+    getItemStatistics(key: string): StatisticsItem;
+    setItemStatistics(key: string, value: number, tsLastUpdate: number): void;
+    removeItemStatistics(key: string): void;
+    getRemoveStatus(): RemoveStatusItem;
+    setRemoveStatus(tsRemove: number, reason?: string): void;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/InventoryItem.d.ts

@@ -0,0 +1,5 @@
+export interface InventoryItem {
+    itemId: string;
+    catalogId: string;
+    classId: string;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/MasterPlayer.d.ts

@@ -0,0 +1,19 @@
+import * as mongoDB from "mongodb";
+import { ExternalItem } from "./ExternalItem";
+import { PlayerBase } from "./PlayerBase";
+export declare class MasterPlayer extends PlayerBase {
+    private static readonly _external;
+    private static readonly _userId;
+    private static readonly _email;
+    private readonly userId;
+    private external;
+    private email;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentMasterPlayer;
+    getUserId(): string;
+    getPassword(): string;
+    getExternal(): ExternalItem;
+    setExternal(externalItem: ExternalItem): void;
+    getEmail(): string;
+    setEmail(email: string): void;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/Match.d.ts

@@ -0,0 +1,28 @@
+import * as mongoDB from "mongodb";
+import { MongoObject } from "./MongoObject";
+import { MatchMember } from "./MatchMember";
+import { ServerDetail } from "./ServerDetail";
+export declare class Match extends MongoObject {
+    private static readonly _matchId;
+    private static readonly _queueName;
+    private static readonly _members;
+    private static readonly _serverDetail;
+    private static readonly _tsCreate;
+    private static readonly _timeToMatchInSeconds;
+    static readonly DOT: string;
+    private readonly matchId;
+    private readonly queueName;
+    private readonly members;
+    private readonly tsCreate;
+    private readonly timeToMatchInSeconds;
+    private serverDetail;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentMatch;
+    getMatchId(): string;
+    getQueueName(): string;
+    getMembers(): Array<MatchMember>;
+    getServerDetail(): ServerDetail;
+    setServerDetail(serverDetail: ServerDetail): void;
+    getTsCreate(): number;
+    getTimeToMatchInSeconds(): number;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/MatchMember.d.ts

@@ -0,0 +1,6 @@
+import { DataValueType } from "./type/DataValueType";
+export interface MatchMember {
+    teamId: string;
+    userId: string;
+    attribute: Map<string, DataValueType>;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/MatchmakingTicket.d.ts

@@ -0,0 +1,46 @@
+import * as mongoDB from "mongodb";
+import { MongoObject } from "./MongoObject";
+import { DataValueType } from "./type/DataValueType";
+import { MatchmakingTicketMember } from "./MatchmakingTicketMember";
+export declare class MatchmakingTicket extends MongoObject {
+    private static readonly _ticketId;
+    private static readonly _queueName;
+    private static readonly _creatorId;
+    private static readonly _giveUpAfterSeconds;
+    private static readonly _userIds;
+    private static readonly _members;
+    private static readonly _status;
+    private static readonly _matchId;
+    private static readonly _tsCreate;
+    static readonly DOT: string;
+    private readonly ticketId;
+    private readonly queueName;
+    private readonly creatorId;
+    private readonly giveUpAfterSeconds;
+    private readonly userIds;
+    private readonly members;
+    private readonly tsCreate;
+    private status;
+    private matchId;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentMatchmakingTicket;
+    getTicketId(): string;
+    getQueueName(): string;
+    getCreatorId(): string;
+    getGiveUpAfterSeconds(): number;
+    getUserIds(): Array<string>;
+    getMembers(): Array<MatchmakingTicketMember>;
+    setMemberStatus(userId: string, status: number): void;
+    setMemberAttribute(userId: string, attribute: {
+        [k: string]: DataValueType;
+    }, attributeForQueue: {
+        [k: string]: DataValueType;
+    }): void;
+    getMember(userId: string): MatchmakingTicketMember;
+    hasMember(userId: string): boolean;
+    getTsCreate(): number;
+    getStatus(): number;
+    setStatus(status: number): void;
+    getMatchId(): string;
+    setMatchId(matchId: string): void;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/MatchmakingTicketMember.d.ts

@@ -0,0 +1,11 @@
+import { DataValueType } from "./type/DataValueType";
+export interface MatchmakingTicketMember {
+    userId: string;
+    status: number;
+    attribute: {
+        [k: string]: DataValueType;
+    };
+    attributeForQueue: {
+        [k: string]: DataValueType;
+    };
+}

package/dist/GN-library/xdatabase/lib/entity/pro/MemberItem.d.ts

@@ -0,0 +1,4 @@
+export interface MemberItem {
+    memberId: string;
+    status: number;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/MongoObject.d.ts

@@ -0,0 +1,18 @@
+import * as mongoDB from "mongodb";
+export declare class MongoObject {
+    private static readonly __id;
+    private static readonly EMPTY_STR;
+    private readonly collection;
+    protected readonly _id: mongoDB.ObjectId;
+    private updateFilter;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    protected inc(field: string, value: number): void;
+    protected min(field: string, value: any): void;
+    protected max(field: string, value: any): void;
+    protected mul(field: string, value: number): void;
+    protected rename(field: string, newField: string): void;
+    protected set(field: string, value: any): void;
+    protected setOnInsert(field: string, value: any): void;
+    protected unset(field: string): void;
+    saveAsync(): Promise<mongoDB.UpdateResult>;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/OwnerItem.d.ts

@@ -0,0 +1,4 @@
+export interface OwnerItem {
+    id: string;
+    type: number;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/PlayerBase.d.ts

@@ -0,0 +1,48 @@
+import * as mongoDB from "mongodb";
+import { BanItem } from "./BanItem";
+import { DataItem } from "./DataItem";
+import { DataObjectBase } from "./DataObjectBase";
+import { CurrencyItem } from "./CurrencyItem";
+import { StatisticsItem } from "./StatisticsItem";
+import { DataValueType } from "./type/DataValueType";
+export declare class PlayerBase extends DataObjectBase {
+    private static readonly _playerBan;
+    private static readonly _playerCurrencies;
+    private static readonly _playerStatistics;
+    private static readonly _playerDatas;
+    private static readonly _ipAddressCreate;
+    private static readonly _countryCode;
+    private static readonly _tsLastLogin;
+    private playerBan;
+    private playerCurrencies;
+    private playerStatistics;
+    private playerDatas;
+    private ipAddressCreate;
+    private countryCode;
+    private tsLastLogin;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentPlayerBase;
+    getPlayerBan(): BanItem;
+    setPlayerBan(tsExpire: number, reason: string): void;
+    getAllPlayerDatas(): Array<DataItem>;
+    hasPlayerData(key: string): boolean;
+    getPlayerData(key: string): DataItem;
+    setPlayerData(key: string, value: DataValueType): void;
+    removePlayerData(key: string): void;
+    getAllPlayerCurrencies(): Map<string, CurrencyItem>;
+    hasPlayerCurrency(key: string): boolean;
+    getPlayerCurrency(key: string): CurrencyItem;
+    setPlayerCurrency(key: string, value: number): void;
+    removePlayerCurrency(key: string): void;
+    getAllPlayerStatistics(): Map<string, StatisticsItem>;
+    hasPlayerStatistics(key: string): boolean;
+    getPlayerStatistics(key: string): StatisticsItem;
+    setPlayerStatistics(key: string, value: number, tsLastUpdate: number): void;
+    removePlayerStatistics(key: string): void;
+    getIpAddressCreate(): string;
+    setIpAddressCreate(ipAddressCreate: string): void;
+    getCountryCode(): string;
+    setCountryCode(countryCode: string): void;
+    getTsLastLogin(): number;
+    setTsLastLogin(tsLastLogin: number): void;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/RemoveStatusItem.d.ts

@@ -0,0 +1,4 @@
+export interface RemoveStatusItem {
+    tsRemove: number;
+    reason?: string;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/ServerDetail.d.ts

@@ -0,0 +1,9 @@
+export interface ServerDetail {
+    ipV4Address: string;
+    ports: {
+        name: string;
+        publicPort: number;
+        privatePort: number;
+        protocol: 1 | 2;
+    }[];
+}

package/dist/GN-library/xdatabase/lib/entity/pro/StatisticsItem.d.ts

@@ -0,0 +1,4 @@
+export interface StatisticsItem {
+    value: number;
+    tsLastUpdate: number;
+}

package/dist/GN-library/xdatabase/lib/entity/pro/StoreInventory.d.ts

@@ -0,0 +1,65 @@
+import * as mongoDB from "mongodb";
+import { DataObjectBase } from "./DataObjectBase";
+import { RemoveStatusItem } from "./RemoveStatusItem";
+import { DataItem } from "./DataItem";
+import { DataValueType } from "./type/DataValueType";
+interface StoreInventoryItem {
+    catalogId: string;
+    classId: string;
+    amount: number;
+}
+interface CurrencyItem {
+    key: string;
+    value: number;
+}
+interface InAppPurchase {
+    appleAppStoreId: string;
+    googlePlayStoreId: string;
+    facebookStoreId: string;
+}
+export declare class StoreInventory extends DataObjectBase {
+    private static readonly _storeId;
+    private static readonly _storeItems;
+    private static readonly _storeCurrencies;
+    private static readonly _priceCurrencies;
+    private static readonly _inAppPurchase;
+    private static readonly _storeDatas;
+    private static readonly _removeStatus;
+    private readonly storeId;
+    private storeItems;
+    private storeCurrencies;
+    private priceCurrencies;
+    private inAppPurchase;
+    private storeDatas;
+    private removeStatus;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentStoreInventory;
+    getStoreId(): string;
+    getAllStoreItems(): Array<StoreInventoryItem>;
+    clearStoreItems(): void;
+    hasStoreItem(catalogId: string, classId: string): boolean;
+    setStoreItem(catalogId: string, classId: string, amount: number): void;
+    removeStoreItem(catalogId: string, classId: string): void;
+    getAllStoreCurrencies(): Array<CurrencyItem>;
+    clearStoreCurrencies(): void;
+    hasStoreCurrency(key: string): boolean;
+    setStoreCurrency(key: string, value: number): void;
+    removeStoreCurrency(key: string): void;
+    getRemoveStatus(): RemoveStatusItem;
+    setRemoveStatus(tsRemove: number, reason?: string): void;
+    getAllPriceCurrencies(): Array<CurrencyItem>;
+    clearPriceCurrencies(): void;
+    getPriceCurrency(key: string): CurrencyItem;
+    hasPriceCurrency(key: string): boolean;
+    setPriceCurrency(key: string, value: number): void;
+    removePriceCurrency(key: string): void;
+    setInAppPurchase(inAppPurchase: InAppPurchase): void;
+    getInAppPurchase(): InAppPurchase;
+    getAllStoreDatas(): Array<DataItem>;
+    clearStoreDatas(): void;
+    hasStoreData(key: string): boolean;
+    getStoreData(key: string): DataItem;
+    setStoreData(key: string, value: DataValueType): void;
+    removeStoreData(key: string): void;
+}
+export {};