@xmobitea/gn-server 2.0.1

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

@@ -0,0 +1,59 @@
+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";
+import { CurrencyItem } from "./CurrencyItem";
+import { InventoryItem } from "./InventoryItem";
+export declare class TradeInventory extends DataObjectBase {
+    private static readonly _tradeId;
+    private static readonly _tradeItems;
+    private static readonly _owner;
+    private static readonly _buyer;
+    private static readonly _tsBuy;
+    private static readonly _prices;
+    private static readonly _itemDatas;
+    private static readonly _itemStatistics;
+    private static readonly _removeStatus;
+    private readonly tradeId;
+    private tradeItems;
+    private owner;
+    private buyer;
+    private tsBuy;
+    private prices;
+    private itemDatas;
+    private itemStatistics;
+    private removeStatus;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentTradeInventory;
+    getTradeId(): string;
+    getAllTradeItems(): Array<InventoryItem>;
+    hasTradeItem(itemId: string): boolean;
+    getTradeItem(itemId: string): InventoryItem;
+    setTradeItem(itemId: string, catalogId: string, classId: string): void;
+    removeTradeItem(itemId: string): void;
+    getOwner(): OwnerItem;
+    setOwner(ownerId: string, ownerType: number): void;
+    getBuyer(): OwnerItem;
+    setBuyer(buyerId: string, buyerType: number): void;
+    setTsBuy(tsBuy: 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;
+    getAllPrices(): Map<string, CurrencyItem>;
+    hasPrice(key: string): boolean;
+    getPrice(key: string): CurrencyItem;
+    setPrice(key: string, value: number): void;
+    removePrice(key: string): void;
+}

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

@@ -0,0 +1,40 @@
+import * as mongoDB from "mongodb";
+import { MongoObject } from "./MongoObject";
+import { RemoveStatusItem } from "./RemoveStatusItem";
+interface FileUpload {
+    mimeType: string;
+    size: string;
+    folderFileName: string;
+}
+export declare class UploadFileInfo extends MongoObject {
+    private static readonly _fileId;
+    private static readonly _userId;
+    private static readonly _fileName;
+    private static readonly _tsCreate;
+    private static readonly _tsUploadExpire;
+    private static readonly _removeStatus;
+    private static readonly _fileUpload;
+    private readonly fileId;
+    private userId;
+    private fileName;
+    private tsCreate;
+    private tsUploadExpire;
+    private removeStatus;
+    private fileUpload;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentUploadFileInfo;
+    getFileId(): string;
+    getUserId(): string;
+    setUserId(userId: string): void;
+    getFileName(): string;
+    setFileName(fileName: string): void;
+    getTsUploadExpire(): number;
+    setTsUploadExpire(tsUploadExpire: number): void;
+    getTsCreate(): number;
+    setTsCreate(tsCreate: number): void;
+    getRemoveStatus(): RemoveStatusItem;
+    setRemoveStatus(tsRemove: number, reason?: string): void;
+    getFileUpload(): FileUpload;
+    setUploadFile(mimeType: string, size: string, folderFileName: string): void;
+}
+export {};

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

@@ -0,0 +1,23 @@
+export interface CharacterPlayerFindOptions {
+    characterId?: boolean;
+    catalogId?: boolean;
+    owner?: boolean;
+    removeStatus?: boolean;
+    segments?: boolean;
+    customDatas?: boolean;
+    displayName?: boolean;
+    avatar?: boolean;
+    tsCreate?: boolean;
+    tags?: boolean;
+    playerBan?: boolean;
+    playerDatas?: boolean;
+    playerCurrencies?: boolean;
+    playerStatistics?: boolean;
+    playerCharacters?: boolean;
+    playerInventories?: boolean;
+    playerGroups?: boolean;
+    playerFriends?: boolean;
+    tsLastLogin?: boolean;
+    ipAddressCreate?: boolean;
+    countryCode?: boolean;
+}

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

@@ -0,0 +1,21 @@
+export interface GamePlayerFindOptions {
+    userId?: boolean;
+    socketId?: boolean;
+    segments?: boolean;
+    customDatas?: boolean;
+    displayName?: boolean;
+    avatar?: boolean;
+    tsCreate?: boolean;
+    tags?: boolean;
+    playerBan?: boolean;
+    playerDatas?: boolean;
+    playerCurrencies?: boolean;
+    playerStatistics?: boolean;
+    playerCharacters?: boolean;
+    playerInventories?: boolean;
+    playerGroups?: boolean;
+    playerFriends?: boolean;
+    tsLastLogin?: boolean;
+    ipAddressCreate?: boolean;
+    countryCode?: boolean;
+}

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

@@ -0,0 +1,17 @@
+export interface GroupFindOptions {
+    groupId?: boolean;
+    groupType?: boolean;
+    catalogId?: boolean;
+    members?: boolean;
+    removeStatus?: boolean;
+    segments?: boolean;
+    customDatas?: boolean;
+    displayName?: boolean;
+    avatar?: boolean;
+    tsCreate?: boolean;
+    tags?: boolean;
+    groupDatas?: boolean;
+    groupCurrencies?: boolean;
+    groupStatistics?: boolean;
+    groupInventories?: boolean;
+}

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

@@ -0,0 +1,17 @@
+export interface InventoryFindOptions {
+    itemId?: boolean;
+    catalogId?: boolean;
+    classId?: boolean;
+    itemType?: boolean;
+    amount?: boolean;
+    owner?: boolean;
+    removeStatus?: boolean;
+    segments?: boolean;
+    customDatas?: boolean;
+    displayName?: boolean;
+    avatar?: boolean;
+    tsCreate?: boolean;
+    tags?: boolean;
+    itemDatas?: boolean;
+    itemStatistics?: boolean;
+}

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

@@ -0,0 +1,18 @@
+export interface MasterPlayerFindOptions {
+    userId?: boolean;
+    external?: boolean;
+    segments?: boolean;
+    customDatas?: boolean;
+    displayName?: boolean;
+    avatar?: boolean;
+    tsCreate?: boolean;
+    tags?: boolean;
+    playerBan?: boolean;
+    playerCurrencies?: boolean;
+    playerStatistics?: boolean;
+    playerDatas?: boolean;
+    ipAddressCreate?: boolean;
+    countryCode?: boolean;
+    tsLastLogin?: boolean;
+    email?: boolean;
+}

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

@@ -0,0 +1,13 @@
+export interface StoreInventoryFindOptions {
+    storeId?: boolean;
+    storeItems?: boolean;
+    storeCurrencies?: boolean;
+    priceCurrencies?: boolean;
+    inAppPurchase?: boolean;
+    removeStatus?: boolean;
+    displayName?: boolean;
+    avatar?: boolean;
+    tsCreate?: boolean;
+    tags?: boolean;
+    storeDatas?: boolean;
+}

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

@@ -0,0 +1,37 @@
+import * as mongoDB from "mongodb";
+import { MasterAdminMongoObject } from "./MasterAdminMongoObject";
+import { xGameSettings } from "./../../../../../xsettings/lib/entity/xGameSettings";
+import { xMatchmakingQueueSettings } from "./../../../../../xsettings/lib/entity/xMatchmakingQueueSettings";
+export declare class GameItem extends MasterAdminMongoObject {
+    private static readonly _gameId;
+    private static readonly _gameName;
+    private static readonly _gameDescription;
+    private static readonly _gameIconUrl;
+    private static readonly _tsCreate;
+    private static readonly _creatorId;
+    private static readonly _gameSettings;
+    private static readonly _matchmakingQueueSettings;
+    private readonly gameId;
+    private readonly tsCreate;
+    private readonly creatorId;
+    private gameName;
+    private gameDescription;
+    private gameIconUrl;
+    private gameSettings;
+    private matchmakingQueueSettings;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentMasterGameItem;
+    getGameId(): string;
+    getTsCreate(): number;
+    getCreatorId(): string;
+    getGameName(): string;
+    setGameName(gameName: string): void;
+    getGameDescription(): string;
+    setGameDescription(gameDescription: string): void;
+    getGameIconUrl(): string;
+    setGameIconUrl(gameIconUrl: string): void;
+    getGameSettings(): xGameSettings;
+    setGameSettings(gameSettings: xGameSettings): void;
+    getMatchmakingQueueSettings(): xMatchmakingQueueSettings[];
+    setMatchmakingQueueSettings(matchmakingQueueSettings: xMatchmakingQueueSettings[]): void;
+}

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

@@ -0,0 +1,10 @@
+import { xCharacterPlayerSettings } from "./../../../../../xsettings/lib/entity/xCharacterPlayerSettings";
+import { xGamePlayerSettings } from "./../../../../../xsettings/lib/entity/xGamePlayerSettings";
+import { xGroupSettings } from "./../../../../../xsettings/lib/entity/xGroupSettings";
+import { xInventorySettings } from "./../../../../../xsettings/lib/entity/xInventorySettings";
+export interface GameSettings {
+    gamePlayerSettings: xGamePlayerSettings;
+    characterPlayerSettings: xCharacterPlayerSettings;
+    groupSettings: xGroupSettings;
+    inventorySettings: xInventorySettings;
+}

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

@@ -0,0 +1,8 @@
+import * as mongoDB from "mongodb";
+import { MongoObject } from "./../MongoObject";
+export declare class MasterAdminMongoObject extends MongoObject {
+    private static readonly _type;
+    private readonly type;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    getType(): string;
+}

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

@@ -0,0 +1,21 @@
+import * as mongoDB from "mongodb";
+import { MasterAdminMongoObject } from "./MasterAdminMongoObject";
+export declare class MasterAdminPlayer extends MasterAdminMongoObject {
+    private static readonly _userId;
+    private static readonly _username;
+    private static readonly _password;
+    private static readonly _secretKey;
+    private readonly userId;
+    private username;
+    private password;
+    private secretKey;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentMasterAdminPlayer;
+    getUserId(): string;
+    getUsername(): string;
+    getPassword(): string;
+    getSecretKey(): string;
+    setUsername(username: string): void;
+    setPassword(password: string): void;
+    setSecretKey(secretKey: string): void;
+}

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

@@ -0,0 +1,16 @@
+import * as mongoDB from "mongodb";
+import { MasterAdminMongoObject } from "./MasterAdminMongoObject";
+import { xThirtPartySettings } from "./../../../../../xsettings/lib/entity/xThirtPartySettings";
+import { xMasterPlayerSettings } from "./../../../../../xsettings/lib/entity/xMasterPlayerSettings";
+export declare class MasterGameSettings extends MasterAdminMongoObject {
+    private static readonly _thirtPartySettings;
+    private static readonly _masterPlayerSettings;
+    private thirtPartySettings;
+    private masterPlayerSettings;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentMasterGameSettings;
+    getThirtPartySettings(): xThirtPartySettings;
+    setThirtPartySettings(thirtPartySettings: xThirtPartySettings): void;
+    getMasterPlayerSettings(): xMasterPlayerSettings;
+    setMasterPlayerSettings(masterPlayerSettings: xMasterPlayerSettings): void;
+}

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

@@ -0,0 +1,34 @@
+import * as mongoDB from "mongodb";
+import { MasterAdminMongoObject } from "./MasterAdminMongoObject";
+import { SecretPermissionItem } from "./../../../../../../GN-common/entity/SecretInfo";
+export declare class SecretInfoItem extends MasterAdminMongoObject {
+    private static readonly _gameId;
+    private static readonly _secretKey;
+    private static readonly _role;
+    private static readonly _remove;
+    private static readonly _tsExpire;
+    private static readonly _permission;
+    private static readonly _tsCreate;
+    private static readonly _creatorId;
+    private readonly gameId;
+    private readonly secretKey;
+    private readonly role;
+    private readonly tsCreate;
+    private readonly creatorId;
+    private remove;
+    private tsExpire;
+    private permission;
+    constructor(result: mongoDB.WithId<mongoDB.Document>, collection: mongoDB.Collection<mongoDB.Document>);
+    private setDocumentMasterSecretInfoItem;
+    getGameId(): string;
+    getSecretKey(): string;
+    getRole(): number;
+    getTsCreate(): number;
+    getCreatorId(): string;
+    getRemove(): boolean;
+    setRemove(isRemove: boolean): void;
+    getTsExpire(): number;
+    setTsExpire(tsExpire: number): void;
+    getPermission(): SecretPermissionItem;
+    setPermission(permission: SecretPermissionItem): void;
+}

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

@@ -0,0 +1,3 @@
+export type DataValueType = string | number | boolean | null | {
+    [k: string]: DataValueType;
+} | Array<DataValueType>;

package/dist/GN-library/xdatabase/lib/xDatabase.d.ts

@@ -0,0 +1,125 @@
+import * as mongoDB from "mongodb";
+import { OnRunSuccess } from "./../../xbuilder/lib/OnRunSuccess";
+import { MasterPlayer } from "./entity/pro/MasterPlayer";
+import { GamePlayer } from "./entity/pro/GamePlayer";
+import { CharacterPlayer } from "./entity/pro/CharacterPlayer";
+import { MasterPlayerFindOptions } from "./entity/pro/findOptions/MasterPlayerFindOptions";
+import { GamePlayerFindOptions } from "./entity/pro/findOptions/GamePlayerFindOptions";
+import { CharacterPlayerFindOptions } from "./entity/pro/findOptions/CharacterPlayerFindOptions";
+import { Group } from "./entity/pro/Group";
+import { Inventory } from "./entity/pro/Inventory";
+import { GroupFindOptions } from "./entity/pro/findOptions/GroupFindOptions";
+import { InventoryFindOptions } from "./entity/pro/findOptions/InventoryFindOptions";
+import { StoreInventoryFindOptions } from "./entity/pro/findOptions/StoreInventoryFindOptions";
+import { StoreInventory } from "./entity/pro/StoreInventory";
+import { UploadFileInfo } from "./entity/pro/UploadFileInfo";
+interface OnMongoRunError {
+    (error: mongoDB.AnyError): void;
+}
+export declare class xDatabase {
+    private static readonly DOT;
+    private static readonly RUNTIME;
+    private static readonly META;
+    private static readonly SYSTEM;
+    private client;
+    private db;
+    getDb(): mongoDB.Db;
+    init(url: string, dbName: string, options?: mongoDB.MongoClientOptions): void;
+    run(onMongoRunSuccess?: OnRunSuccess, onMongoRunError?: OnMongoRunError): void;
+    runtimeCollection(collectionName: string): mongoDB.Collection<mongoDB.Document>;
+    metaCollection(collectionName: string): mongoDB.Collection<mongoDB.Document>;
+    systemCollection(collectionName: string): mongoDB.Collection<mongoDB.Document>;
+    runtimeGameCollection(collectionName: string, gameId: string): mongoDB.Collection<mongoDB.Document>;
+    metaGameCollection(collectionName: string, gameId: string): mongoDB.Collection<mongoDB.Document>;
+    systemGameCollection(collectionName: string, gameId: string): mongoDB.Collection<mongoDB.Document>;
+    collection(fullCollectionName: string): mongoDB.Collection<mongoDB.Document>;
+    createCollection(collectionName: string, options?: mongoDB.CreateCollectionOptions): Promise<mongoDB.Collection<mongoDB.BSON.Document>>;
+    createIndex(collectionName: string, index: {
+        [k: string]: any;
+    }, options?: {
+        [k: string]: any;
+    }): void;
+    private convertToMasterPlayers;
+    loadMasterPlayersWithGoogleAsync(googleIds: string[], masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadMasterPlayersWithFacebookAsync(facebookIds: string[], masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadMasterPlayersWithAppleAsync(appleIds: string[], masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadMasterPlayersWithGenericServiceAsync(genericService: string, genericIds: string[], masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadMasterPlayersWithSegmentAsync(segment: string, skip: number, limit: number, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadMasterPlayersWithTagAsync(key: string, value: string, skip: number, limit: number, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadMasterPlayersWithDisplayNameAsync(keyword: string, skip: number, limit: number, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadMasterPlayerWithDisplayNameAsync(displayName: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayersLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadMasterPlayersLeaderboardWithCurrenciesAsync(key: string, skip: number, limit: number, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<Array<MasterPlayer>>;
+    loadPositionMasterPlayerLeaderboardWithStatisticsAsync(key: string, userId: string): Promise<number>;
+    loadPositionMasterPlayerLeaderboardWithCurrencies(key: string, userId: string): Promise<number>;
+    loadMasterPlayerAsync(userId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByCustomDeviceIdAsync(customDeviceId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByAndroidDeviceIdAsync(androidDeviceId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByiOSDeviceIdAsync(iOSDeviceId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByWindowsPhoneDeviceIdAsync(windowsPhoneDeviceId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByWindowsDeviceIdAsync(windowsDeviceId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByLinuxDeviceIdAsync(linuxDeviceId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByMacOSDeviceIdAsync(macOSDeviceId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByEditorDeviceIdAsync(editorDeviceId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByAccountUsernameAsync(username: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByCustomIdAsync(customId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByAppleAsync(appleId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByGoogleAsync(googleId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByFacebookAsync(facebookId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    loadMasterPlayerByGenericServiceAsync(serviceName: string, serviceId: string, masterPlayerFindOptions?: MasterPlayerFindOptions): Promise<MasterPlayer>;
+    createMasterPlayerAsync(result: any): Promise<MasterPlayer>;
+    private convertToGamePlayers;
+    loadGamePlayersWithSegmentAsync(segment: string, skip: number, limit: number, gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
+    loadGamePlayersWithTagAsync(key: string, value: string, skip: number, limit: number, gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
+    loadGamePlayersWithDisplayNameAsync(keyword: string, skip: number, limit: number, gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
+    loadGamePlayerWithDisplayNameAsync(displayName: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<GamePlayer>;
+    loadGamePlayersLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
+    loadFriendGamePlayersLeaderboardWithStatisticsAsync(friendIds: string[], gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
+    loadGamePlayersLeaderboardWithCurrenciesAsync(key: string, skip: number, limit: number, gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<Array<GamePlayer>>;
+    loadPositionGamePlayerLeaderboardWithStatisticsAsync(key: string, userId: string, gameId: string): Promise<number>;
+    loadPositionGamePlayerLeaderboardWithCurrenciesAsync(key: string, userId: string, gameId: string): Promise<number>;
+    loadGamePlayerAsync(userId: string, gameId: string, gamePlayerFindOptions?: GamePlayerFindOptions): Promise<GamePlayer>;
+    createGamePlayerAsync(result: any, gameId: string): Promise<GamePlayer>;
+    private convertToCharacterPlayers;
+    loadCharacterPlayersWithSegmentAsync(segment: string, skip: number, limit: number, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
+    loadCharacterPlayersWithTagAsync(key: string, value: string, skip: number, limit: number, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
+    loadCharacterPlayersWithDisplayNameAsync(keyword: string, skip: number, limit: number, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
+    loadCharacterPlayersLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
+    loadCharacterPlayersLeaderboardWithCurrenciesAsync(key: string, skip: number, limit: number, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
+    loadPositionCharacterPlayerLeaderboardWithStatisticsAsync(key: string, userId: string, gameId: string): Promise<number>;
+    loadPositionCharacterPlayerLeaderboardWithCurrenciesAsync(key: string, userId: string, gameId: string): Promise<number>;
+    loadFriendCharacterPlayersLeaderboardWithStatisticsAsync(friendIds: string[], gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<Array<CharacterPlayer>>;
+    loadCharacterPlayerAsync(characterId: string, gameId: string, characterPlayerFindOptions?: CharacterPlayerFindOptions): Promise<CharacterPlayer>;
+    createCharacterPlayerAsync(result: any, gameId: string): Promise<CharacterPlayer>;
+    private convertToGroups;
+    loadGroupsWithSegmentAsync(segment: string, skip: number, limit: number, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
+    loadGroupsWithTagAsync(key: string, value: string, skip: number, limit: number, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
+    loadGroupsWithDisplayNameAsync(keyword: string, skip: number, limit: number, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
+    loadGroupsLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
+    loadGroupsLeaderboardWithCurrenciesAsync(key: string, skip: number, limit: number, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Array<Group>>;
+    loadPositionGroupLeaderboardWithStatisticsAsync(key: string, groupId: string, gameId: string): Promise<number>;
+    loadPositionGroupLeaderboardWithCurrenciesAsync(key: string, groupId: string, gameId: string): Promise<number>;
+    loadGroupAsync(groupId: string, gameId: string, groupFindOptions?: GroupFindOptions): Promise<Group>;
+    createGroupAsync(result: any, gameId: string): Promise<Group>;
+    private convertToInventories;
+    loadInventoriesWithSegmentAsync(segment: string, skip: number, limit: number, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
+    loadInventoriesWithTagAsync(key: string, value: string, skip: number, limit: number, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
+    loadInventoriesWithDisplayNameAsync(keyword: string, skip: number, limit: number, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
+    loadInventoriesLeaderboardWithStatisticsAsync(key: string, skip: number, limit: number, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Array<Inventory>>;
+    loadPositionInventoryLeaderboardWithStatisticsAsync(key: string, itemId: string, gameId: string): Promise<number>;
+    loadInventoryAsync(itemId: string, gameId: string, inventoryFindOptions?: InventoryFindOptions): Promise<Inventory>;
+    createInventoryAsync(result: any, gameId: string): Promise<Inventory>;
+    private convertToStoreInventories;
+    loadStoreInventoryAsync(storeId: string, gameId: string, storeInventoryFindOptions?: StoreInventoryFindOptions): Promise<StoreInventory>;
+    loadStoreInventoryByFacebookStoreAsync(productId: string, gameId: string, storeInventoryFindOptions?: StoreInventoryFindOptions): Promise<StoreInventory>;
+    loadStoreInventoryByAppleAppStoreAsync(productId: string, gameId: string, storeInventoryFindOptions?: StoreInventoryFindOptions): Promise<StoreInventory>;
+    loadStoreInventoryByGooglePlayStoreAsync(productId: string, gameId: string, storeInventoryFindOptions?: StoreInventoryFindOptions): Promise<StoreInventory>;
+    loadStoreInventoriesWithTagAsync(key: string, value: string, skip: number, limit: number, gameId: string, storeInventoryFindOptions?: StoreInventoryFindOptions): Promise<Array<StoreInventory>>;
+    createStoreInventoryAsync(result: any, gameId: string): Promise<StoreInventory>;
+    loadGroupMessagesAsync(groupId: string, gameId: string, skip: number, limit: number): Promise<mongoDB.FindCursor<mongoDB.WithId<mongoDB.Document>>>;
+    createGroupMessageAsync(groupId: string, gameId: string, senderId: string, senderType: number, message: string, tsCreate: number): Promise<mongoDB.Document>;
+    loadUploadFileInfoAsync(fileId: string): Promise<UploadFileInfo>;
+    createUploadFileInfoAsync(result: any): Promise<UploadFileInfo>;
+    private getFindOptions;
+}
+export {};

package/dist/GN-library/xdatetime/lib/xDatetime.d.ts

@@ -0,0 +1,14 @@
+export declare class xDatetime {
+    static readonly ONE_SECOND_MILLISECOND: number;
+    static readonly ONE_MINUTE_MILLISECOND: number;
+    static readonly ONE_HOUR_MILLISECOND: number;
+    static readonly ONE_DAY_MILLISECOND: number;
+    static readonly ONE_WEEK_MILLISECOND: number;
+    static readonly ONE_MONTH_MILLISECOND: number;
+    static readonly ONE_YEAR_MILLISECOND: number;
+    static getCurrentMilliseconds(): number;
+    static getCurrentDate(): Date;
+    static getMilliseconds(date: Date): number;
+    static getDateAtMilliseconds(milliseconds: number): Date;
+    static getToday0hMilliseconds(): number;
+}

package/dist/GN-library/xdebug/lib/xDebug.d.ts

@@ -0,0 +1,19 @@
+interface DebugConfiguration {
+    isLogToFileEnable: boolean;
+    isLogToConsoleEnable: boolean;
+    logPath: string;
+}
+export declare class Debug {
+    private static isLogToFileEnable;
+    private static isLogToConsoleEnable;
+    private static logPath;
+    private static logger;
+    static init(config: DebugConfiguration): void;
+    static run(): void;
+    static log(message: any, ...args: any[]): void;
+    static logInfo(message: any, ...args: any[]): void;
+    static logError(message: any, ...args: any[]): void;
+    static logWarning(message: any, ...args: any[]): void;
+    static logException(exception: Error): void;
+}
+export {};

package/dist/GN-library/xmail/lib/xMail.d.ts

@@ -0,0 +1,16 @@
+import { OnRunSuccess } from "./../../xbuilder/lib/OnRunSuccess";
+interface OnSendMailSuccess {
+    (): void;
+}
+interface OnSendMailError {
+    (error: string): void;
+}
+export declare class xMail {
+    private isInit;
+    private sendGridApiKey;
+    private fromEmail;
+    init(sendGridApiKey: string, fromEmail: string): void;
+    run(onRunSuccess?: OnRunSuccess): void;
+    sendMail(toEmail: string, subject: string, contentHTML: string, onSendMailSuccess?: OnSendMailSuccess, onSendMailError?: OnSendMailError): Promise<void>;
+}
+export {};

package/dist/GN-library/xrandom/lib/xRandom.d.ts

@@ -0,0 +1,4 @@
+export declare class xRandom {
+    static randomFloat(min: number, max: number): number;
+    static randomInt(min: number, max: number): number;
+}

package/dist/GN-library/xsettings/lib/entity/xCharacterCatalogSettings.d.ts

@@ -0,0 +1,4 @@
+export interface xCharacterCatalogSettings {
+    catalogId: string;
+    displayName: string;
+}

package/dist/GN-library/xsettings/lib/entity/xCharacterPlayerSettings.d.ts

@@ -0,0 +1,17 @@
+import { xCurrencySettings } from "./xCurrencySettings";
+import { xDataSettings } from "./xDataSettings";
+import { xFriendCatalogSettings } from "./xFriendCatalogSettings";
+import { xGroupCatalogSettings } from "./xGroupCatalogSettings";
+import { xItemCatalogSettings } from "./xItemCatalogSettings";
+import { xStatisticsSettings } from "./xStatisticsSettings";
+import { xTagSettings } from "./xTagSettings";
+export interface xCharacterPlayerSettings {
+    playerCurrencySettings: Array<xCurrencySettings>;
+    playerStatisticsSettings: Array<xStatisticsSettings>;
+    playerDatasSettings: Array<xDataSettings>;
+    customDatasSettings: Array<xDataSettings>;
+    tagsSettings: Array<xTagSettings>;
+    playerGroupCatalogSettings: Array<xGroupCatalogSettings>;
+    playerItemCatalogSettings: Array<xItemCatalogSettings>;
+    playerFriendCatalogSettings: Array<xFriendCatalogSettings>;
+}

package/dist/GN-library/xsettings/lib/entity/xCurrencySettings.d.ts

@@ -0,0 +1,4 @@
+export interface xCurrencySettings {
+    key: string;
+    initialValue: number;
+}

package/dist/GN-library/xsettings/lib/entity/xDataSettings.d.ts

@@ -0,0 +1,4 @@
+export interface xDataSettings {
+    key: string;
+    permission: number;
+}

package/dist/GN-library/xsettings/lib/entity/xFriendCatalogSettings.d.ts

@@ -0,0 +1,4 @@
+export interface xFriendCatalogSettings {
+    catalogId: string;
+    forceAcceptFriend: boolean;
+}

package/dist/GN-library/xsettings/lib/entity/xGamePlayerSettings.d.ts

@@ -0,0 +1,19 @@
+import { xCharacterCatalogSettings } from "./xCharacterCatalogSettings";
+import { xCurrencySettings } from "./xCurrencySettings";
+import { xDataSettings } from "./xDataSettings";
+import { xFriendCatalogSettings } from "./xFriendCatalogSettings";
+import { xGroupCatalogSettings } from "./xGroupCatalogSettings";
+import { xItemCatalogSettings } from "./xItemCatalogSettings";
+import { xStatisticsSettings } from "./xStatisticsSettings";
+import { xTagSettings } from "./xTagSettings";
+export interface xGamePlayerSettings {
+    playerCurrencySettings: Array<xCurrencySettings>;
+    playerStatisticsSettings: Array<xStatisticsSettings>;
+    playerDatasSettings: Array<xDataSettings>;
+    customDatasSettings: Array<xDataSettings>;
+    tagsSettings: Array<xTagSettings>;
+    playerCharacterCatalogSettings: Array<xCharacterCatalogSettings>;
+    playerGroupCatalogSettings: Array<xGroupCatalogSettings>;
+    playerItemCatalogSettings: Array<xItemCatalogSettings>;
+    playerFriendCatalogSettings: Array<xFriendCatalogSettings>;
+}

package/dist/GN-library/xsettings/lib/entity/xGameSettings.d.ts

@@ -0,0 +1,10 @@
+import { xCharacterPlayerSettings } from "./xCharacterPlayerSettings";
+import { xGamePlayerSettings } from "./xGamePlayerSettings";
+import { xGroupSettings } from "./xGroupSettings";
+import { xInventorySettings } from "./xInventorySettings";
+export interface xGameSettings {
+    characterPlayerSettings: xCharacterPlayerSettings;
+    gamePlayerSettings: xGamePlayerSettings;
+    groupSettings: xGroupSettings;
+    inventorySettings: xInventorySettings;
+}

package/dist/GN-library/xsettings/lib/entity/xGenericServiceSettings.d.ts

@@ -0,0 +1,3 @@
+export interface xGenericServiceSettings {
+    serviceName: string;
+}

package/dist/GN-library/xsettings/lib/entity/xGroupCatalogSettings.d.ts

@@ -0,0 +1,5 @@
+export interface xGroupCatalogSettings {
+    catalogId: string;
+    displayName: string;
+    forceAcceptMember: boolean;
+}