@arken/node 1.5.1 → 1.5.3

package/build/modules/core/core.models.js

@@ -1,811 +0,0 @@
-import * as mongo from '../../util/mongo';
-const { createModel, addTagVirtuals, addApplicationVirtual } = mongo;
-export const MerkleTree = createModel('MerkleTree', {
-    root: { type: String, required: true, default: '0x' + '0'.repeat(64) },
-    depth: { type: Number, required: true, default: 16 },
-}, {
-    virtuals: [...addTagVirtuals('MerkleTree'), ...addApplicationVirtual()],
-});
-export const MerkleNode = createModel('MerkleNode', {
-    treeId: { type: mongo.Schema.Types.ObjectId, ref: 'MerkleTree', required: true },
-    level: { type: Number, required: true },
-    index: { type: Number, required: true },
-    hash: { type: String, required: true },
-}, {
-    indexes: [{ treeId: 1, level: 1, index: 1 }],
-    virtuals: [...addTagVirtuals('MerkleNode'), ...addApplicationVirtual()],
-});
-export const Omniverse = createModel('Omniverse', {
-    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
-}, {
-    extend: 'CommonFields',
-    virtuals: [...addTagVirtuals('Omniverse'), ...addApplicationVirtual()],
-});
-export const Metaverse = createModel('Metaverse', {
-    omniverseId: { type: mongo.Schema.Types.ObjectId, ref: 'Omniverse', required: true },
-    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
-}, {
-    extend: 'CommonFields',
-    virtuals: [...addTagVirtuals('Metaverse'), ...addApplicationVirtual()],
-});
-export const Application = createModel('Application', {
-    ownerId: { type: mongo.Schema.Types.ObjectId, ref: 'Account' },
-    metaverseId: { type: mongo.Schema.Types.ObjectId, ref: 'Metaverse' },
-    name: { type: String, required: true },
-    description: { type: String },
-}, {
-    extend: 'CommonFields',
-    indexes: [{ metaverseId: 1, name: 1, unique: true }],
-    virtuals: [
-        ...addTagVirtuals('Application'),
-        { name: 'agents', ref: 'Agent', localField: '_id', foreignField: 'applicationId' },
-        { name: 'chain' },
-        { name: 'account' },
-        { name: 'assets' },
-        { name: 'badges' },
-        { name: 'battlePasses' },
-        { name: 'collections' },
-        { name: 'communities' },
-        { name: 'discussions' },
-        { name: 'events' },
-        { name: 'exchanges' },
-        { name: 'files' },
-        { name: 'ideas' },
-        { name: 'leaderboards' },
-        { name: 'assetLicenses' },
-        { name: 'logs' },
-        { name: 'marketPairs' },
-        { name: 'markets' },
-        { name: 'messages' },
-        { name: 'offers' },
-        { name: 'orders' },
-        { name: 'products' },
-        { name: 'projects' },
-        { name: 'ratings' },
-        { name: 'realms' },
-        { name: 'reviews' },
-        { name: 'roles' },
-        { name: 'realmShards' },
-        { name: 'suggestions' },
-        { name: 'tags' },
-        { name: 'tokens' },
-        { name: 'tradeIdeas' },
-        { name: 'trades' },
-        { name: 'buyerTrades' },
-        { name: 'transactions' },
-        { name: 'votes' },
-        { name: 'payments' },
-        { name: 'permissions' },
-        { name: 'stats' },
-        { name: 'revisions' },
-        { name: 'comments' },
-        { name: 'interfaces' },
-        { name: 'characters' },
-        { name: 'metaverses' },
-        { name: 'omniverses' },
-        { name: 'referrals' },
-        { name: 'recipientReferrals' },
-        { name: 'senderReferrals' },
-        { name: 'chains' },
-        { name: 'characterAbilities' },
-        { name: 'tournaments' },
-        { name: 'teams' },
-        { name: 'items' },
-        { name: 'skills' },
-        { name: 'itemRecipes' },
-        { name: 'itemSkins' },
-        { name: 'stashes' },
-        { name: 'biomes' },
-        { name: 'planets' },
-        { name: 'solarSystems' },
-        { name: 'universes' },
-        { name: 'stars' },
-        { name: 'areas' },
-        { name: 'acts' },
-        { name: 'characterClasses' },
-        { name: 'characterFactions' },
-        { name: 'eras' },
-        { name: 'seasons' },
-        { name: 'itemAttributes' },
-        { name: 'itemMaterials' },
-        { name: 'itemSets' },
-        { name: 'itemSlots' },
-        { name: 'itemRarities' },
-        { name: 'itemTypes' },
-        { name: 'itemSubTypes' },
-        { name: 'itemSpecificTypes' },
-        { name: 'characterGenders' },
-        { name: 'characterRaces' },
-        { name: 'characterPersonalities' },
-        { name: 'characterTitles' },
-        { name: 'lores' },
-        { name: 'energies' },
-        { name: 'guides' },
-        { name: 'achievements' },
-        { name: 'games' },
-        { name: 'npcs' },
-        { name: 'characterAttributes' },
-        { name: 'characterTypes' },
-        { name: 'areaTypes' },
-        { name: 'areaLandmarks' },
-        { name: 'biomeFeatures' },
-        { name: 'skillMods' },
-        { name: 'skillClassifications' },
-        { name: 'skillConditions' },
-        { name: 'skillStatusEffects' },
-        { name: 'skillTrees' },
-        { name: 'skillTreeNodes' },
-        { name: 'areaNameChoices' },
-        { name: 'characterNameChoices' },
-        { name: 'validators' },
-        { name: 'productUpdates' },
-        { name: 'polls' },
-        { name: 'galaxies' },
-        { name: 'quests' },
-        { name: 'raffles' },
-        { name: 'raffleEntries' },
-        { name: 'raffleRequirements' },
-        { name: 'raffleRewards' },
-        { name: 'proposals' },
-        { name: 'companies' },
-        { name: 'people' },
-    ],
-});
-export const Account = createModel('Account', {
-    username: { type: String },
-    email: { type: String },
-    address: { type: String },
-    addressIndex: { type: Number },
-    telegramUserId: { type: Number },
-    activeProfileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' },
-    sessionUserId: { type: String },
-}, {
-    indexes: [
-        {
-            fields: { applicationId: 1, telegramUserId: 1 },
-            options: {
-                unique: true,
-                partialFilterExpression: { telegramUserId: { $exists: true } },
-            },
-        },
-    ],
-    virtuals: [
-        {
-            name: 'profiles',
-            ref: 'Profile',
-            localField: '_id',
-            foreignField: 'accountId',
-            justOne: false,
-        },
-        ...addTagVirtuals('Account'),
-        ...addApplicationVirtual(),
-    ],
-});
-export const Achievement = createModel('Achievement', {}, {
-    virtuals: [...addTagVirtuals('Achievement'), ...addApplicationVirtual()],
-});
-export const Act = createModel('Act', {}, {
-    virtuals: [...addTagVirtuals('Act'), ...addApplicationVirtual()],
-});
-export const Agent = createModel('Agent', {}, {
-    virtuals: [...addTagVirtuals('Agent'), ...addApplicationVirtual()],
-});
-export const Badge = createModel('Badge', {}, {
-    virtuals: [...addTagVirtuals('Badge'), ...addApplicationVirtual()],
-});
-export const BattlePass = createModel('BattlePass', {}, {
-    virtuals: [...addTagVirtuals('BattlePass'), ...addApplicationVirtual()],
-});
-export const Biome = createModel('Biome', {}, {
-    virtuals: [...addTagVirtuals('Biome'), ...addApplicationVirtual()],
-});
-export const BiomeFeature = createModel('BiomeFeature', {}, {
-    virtuals: [...addTagVirtuals('BiomeFeature'), ...addApplicationVirtual()],
-});
-export const Bounty = createModel('Bounty', {}, {
-    virtuals: [...addTagVirtuals('Bounty'), ...addApplicationVirtual()],
-});
-export const Counter = createModel('Counter', { _id: { type: String, required: true }, seq: { type: Number, default: 0 } }, { versionKey: false, virtuals: [...addTagVirtuals('Counter'), ...addApplicationVirtual()] });
-export const Collection = createModel('Collection', {}, {
-    virtuals: [...addTagVirtuals('Collection'), ...addApplicationVirtual()],
-});
-export const Comment = createModel('Comment', {
-    body: { type: String, required: true },
-    entity: { type: mongo.Schema.Types.ObjectId },
-    entityModel: { type: String },
-    text: { type: String },
-    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
-}, {
-    virtuals: [...addTagVirtuals('Comment'), ...addApplicationVirtual()],
-});
-export const Community = createModel('Community', {
-    ideas: [{ type: mongo.Schema.Types.ObjectId, ref: 'Idea' }],
-    products: [{ type: mongo.Schema.Types.ObjectId, ref: 'Product' }],
-    projects: [{ type: mongo.Schema.Types.ObjectId, ref: 'Project' }],
-}, {
-    virtuals: [...addTagVirtuals('Community'), ...addApplicationVirtual()],
-});
-export const Company = createModel('Company', {
-    content: { type: String },
-    people: [{ type: mongo.Schema.Types.ObjectId, ref: 'Person' }],
-}, {
-    virtuals: [...addTagVirtuals('Company'), ...addApplicationVirtual()],
-});
-export const Conversation = createModel('Conversation', {
-    profileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', index: true },
-    kind: {
-        type: String,
-        enum: ['mail', 'dm', 'group', 'support', 'system'],
-        default: 'mail',
-        index: true,
-    },
-    participants: [
-        {
-            profileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: true },
-            role: { type: String, enum: ['user', 'system', 'gm', 'npc'], default: 'user' },
-            lastReadAt: { type: Date, default: new Date(0) },
-            unreadCount: { type: Number, default: 0 },
-            isMuted: { type: Boolean, default: false },
-            isPinned: { type: Boolean, default: false },
-            isArchived: { type: Boolean, default: false },
-            isDeleted: { type: Boolean, default: false },
-        },
-    ],
-    isLocked: { type: Boolean, default: true },
-    allowUserSend: { type: Boolean, default: false },
-    category: { type: String, default: 'system' },
-    importance: { type: Number, default: 0 },
-    lastMessageDate: { type: Date, default: null, index: true },
-    lastMessagePreview: { type: String, default: '' },
-    messageCount: { type: Number, default: 0 },
-    messages: [{ type: mongo.Schema.Types.ObjectId, ref: 'ConversationMessage' }],
-}, {
-    indexes: [
-        { fields: { 'participants.profileId': 1, lastMessageDate: -1 } },
-        { fields: { kind: 1, 'participants.profileId': 1, lastMessageDate: -1 } },
-        { fields: { profileId: 1, kind: 1, lastMessageDate: -1 } },
-        {
-            fields: { key: 1, profileId: 1 },
-            options: {
-                unique: true,
-                partialFilterExpression: { profileId: { $type: 'objectId' } },
-            },
-        },
-        {
-            fields: { kind: 1, profileId: 1 },
-            options: {
-                unique: true,
-                partialFilterExpression: { profileId: { $type: 'objectId' } },
-            },
-        },
-        {
-            fields: { applicationId: 1, kind: 1, profileId: 1, key: 1 },
-            options: {
-                unique: true,
-                partialFilterExpression: { key: { $type: 'string' } },
-            },
-        },
-    ],
-    virtuals: [...addTagVirtuals('Conversation'), ...addApplicationVirtual()],
-});
-export const ConversationMessage = createModel('ConversationMessage', {
-    conversationId: { type: mongo.Schema.Types.ObjectId, ref: 'Conversation', required: true, index: true },
-    role: { type: String, enum: ['user', 'assistant', 'system'], required: true },
-    type: {
-        type: String,
-        enum: ['text', 'notice', 'reward', 'action', 'system'],
-        default: 'text',
-        index: true,
-    },
-    isStarred: { type: Boolean, default: false, index: true },
-    content: { type: String, default: '' },
-    payload: { type: mongo.Schema.Types.Mixed },
-    replyToId: { type: mongo.Schema.Types.ObjectId, ref: 'ConversationMessage' },
-    claim: {
-        isClaimable: { type: Boolean, default: false, index: true },
-        claimedDate: { type: Date, default: null },
-        claimedByProfileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', default: null },
-        dedupeKey: { type: String, default: null },
-        attachments: { type: [mongo.Schema.Types.Mixed], default: [] },
-        revokedDate: { type: Date, default: null },
-        revokeReason: { type: String, default: null },
-    },
-}, {
-    indexes: [
-        { fields: { conversationId: 1, _id: -1 } },
-        { fields: { conversationId: 1, createdDate: -1 } },
-        { fields: { 'claim.isClaimable': 1, 'claim.claimedDate': 1 } },
-        { fields: { conversationId: 1, 'claim.isClaimable': 1, 'claim.claimedDate': 1, _id: -1 } },
-        { fields: { conversationId: 1, 'claim.dedupeKey': 1 } },
-        {
-            fields: { conversationId: 1, 'claim.dedupeKey': 1 },
-            options: {
-                unique: true,
-                partialFilterExpression: { 'claim.dedupeKey': { $type: 'string' } },
-            },
-        },
-        { fields: { isStarred: 1, conversationId: 1, _id: -1 } },
-    ],
-    virtuals: [...addTagVirtuals('ConversationMessage'), ...addApplicationVirtual()],
-});
-export const Data = createModel('Data', {
-    mod: { type: String, required: true },
-}, {
-    virtuals: [...addTagVirtuals('Data'), ...addApplicationVirtual()],
-});
-export const Meta = createModel('Meta', {}, {
-    virtuals: [...addTagVirtuals('Meta'), ...addApplicationVirtual()],
-});
-export const Discussion = createModel('Discussion', {
-    content: { type: String },
-    parentId: { type: mongo.Schema.Types.ObjectId, ref: 'Discussion' },
-    rootMessageId: { type: mongo.Schema.Types.ObjectId, ref: 'Message' },
-    type: { type: String, default: 'Discussion' },
-}, {
-    virtuals: [...addTagVirtuals('Discussion'), ...addApplicationVirtual()],
-});
-export const Energy = createModel('Energy', {}, {
-    virtuals: [...addTagVirtuals('Energy'), ...addApplicationVirtual()],
-});
-export const Event = createModel('Event', {}, {
-    virtuals: [...addTagVirtuals('Event'), ...addApplicationVirtual()],
-});
-export const File = createModel('File', {
-    content: { type: String },
-    storageType: { type: String, max: 100 },
-    accessType: { type: String, max: 100 },
-}, {
-    virtuals: [...addTagVirtuals('File'), ...addApplicationVirtual()],
-});
-export const Galaxy = createModel('Galaxy', {
-    universeId: { type: mongo.Schema.Types.ObjectId, ref: 'Universe' },
-}, {
-    virtuals: [...addTagVirtuals('Galaxy'), ...addApplicationVirtual()],
-});
-export const Guide = createModel('Guide', {
-    content: { type: String },
-    gameId: { type: mongo.Schema.Types.ObjectId, ref: 'Game' },
-    attachments: [mongo.Schema.Types.Mixed],
-}, {
-    virtuals: [...addTagVirtuals('Guide'), ...addApplicationVirtual()],
-});
-export const Idea = createModel('Idea', {
-    type: { type: String, max: 100 },
-    communityId: { type: mongo.Schema.Types.ObjectId, ref: 'Community' },
-}, {
-    virtuals: [...addTagVirtuals('Idea'), ...addApplicationVirtual()],
-});
-export const Leaderboard = createModel('Leaderboard', {
-    productId: { type: mongo.Schema.Types.ObjectId, ref: 'Product' },
-}, {
-    virtuals: [...addTagVirtuals('Leaderboard'), ...addApplicationVirtual()],
-});
-export const Log = createModel('Log', {
-    mod: { type: String, required: true },
-    messages: [mongo.Schema.Types.Mixed],
-}, {
-    virtuals: [...addTagVirtuals('Log'), ...addApplicationVirtual()],
-});
-export const Lore = createModel('Lore', {
-    gameId: { type: mongo.Schema.Types.ObjectId, ref: 'Game' },
-}, {
-    virtuals: [...addTagVirtuals('Lore'), ...addApplicationVirtual()],
-});
-export const Market = createModel('Market', {}, {
-    virtuals: [...addTagVirtuals('Market'), ...addApplicationVirtual()],
-});
-export const Memory = createModel('Memory', {}, {
-    virtuals: [...addTagVirtuals('Memory'), ...addApplicationVirtual()],
-});
-export const Message = createModel('Message', {
-    content: { type: String },
-    type: { type: String, max: 100 },
-    replyToId: { type: mongo.Schema.Types.ObjectId, ref: 'Message' },
-    parentId: { type: mongo.Schema.Types.ObjectId, ref: 'Message' },
-    conversationId: { type: mongo.Schema.Types.ObjectId, ref: 'Conversation' },
-}, {
-    virtuals: [...addTagVirtuals('Message'), ...addApplicationVirtual()],
-});
-export const NewsArticle = createModel('NewsArticle', {
-    href: { type: String, required: true },
-    source: { type: String, required: true },
-}, {
-    virtuals: [...addTagVirtuals('NewsArticle'), ...addApplicationVirtual()],
-});
-export const Npc = createModel('Npc', {
-    characterId: { type: mongo.Schema.Types.ObjectId, ref: 'Character' },
-}, {
-    virtuals: [...addTagVirtuals('Npc'), ...addApplicationVirtual()],
-});
-export const Offer = createModel('Offer', {}, {
-    virtuals: [...addTagVirtuals('Offer'), ...addApplicationVirtual()],
-});
-export const Order = createModel('Order', {}, {
-    virtuals: [...addTagVirtuals('Order'), ...addApplicationVirtual()],
-});
-export const Payment = createModel('Payment', {
-    status: {
-        type: String,
-        default: 'Submitted',
-        enum: [
-            'Archived',
-            'Processing',
-            'Failed',
-            'Submitted',
-            'Denied',
-            'Processed',
-            'Voided',
-            'Completed',
-            'Refunding',
-            'Refunded',
-            'Expired',
-        ],
-    },
-}, {
-    virtuals: [{ name: 'owner' }, ...addTagVirtuals('Payment'), ...addApplicationVirtual()],
-});
-export const Permission = createModel('Permission', {
-    roles: [{ type: mongo.Schema.Types.ObjectId, ref: 'Role' }],
-}, {
-    virtuals: [...addTagVirtuals('Permission'), ...addApplicationVirtual()],
-});
-export const Person = createModel('Person', {
-    content: { type: String },
-    companyId: { type: mongo.Schema.Types.ObjectId, ref: 'Company' },
-}, {
-    virtuals: [...addTagVirtuals('Person'), ...addApplicationVirtual()],
-});
-export const Planet = createModel('Planet', {
-    solarSystemId: { type: mongo.Schema.Types.ObjectId, ref: 'SolarSystem' },
-}, {
-    virtuals: [...addTagVirtuals('Planet'), ...addApplicationVirtual()],
-});
-export const Poll = createModel('Poll', {}, {
-    virtuals: [...addTagVirtuals('Poll'), ...addApplicationVirtual()],
-});
-export const Project = createModel('Project', {
-    content: { type: String },
-    contractStatus: { type: String, default: 'Pending' },
-    parentId: { type: mongo.Schema.Types.ObjectId, ref: 'Project' },
-    realmId: { type: mongo.Schema.Types.ObjectId, ref: 'Realm' },
-    communityId: { type: mongo.Schema.Types.ObjectId, ref: 'Community' },
-    productId: { type: mongo.Schema.Types.ObjectId, ref: 'Product' },
-    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
-}, {
-    virtuals: [...addTagVirtuals('Project'), ...addApplicationVirtual()],
-});
-export const Proposal = createModel('Proposal', {
-    content: { type: String },
-}, {
-    virtuals: [...addTagVirtuals('Proposal'), ...addApplicationVirtual()],
-});
-export const Quest = createModel('Quest', {
-    type: { type: String, default: 'zone' },
-}, {
-    virtuals: [...addTagVirtuals('Quest'), ...addApplicationVirtual()],
-});
-export const Question = createModel('Question', {
-    topics: [mongo.Schema.Types.Mixed],
-    text: { type: String, required: true },
-    answer: { type: String, required: true },
-    popularity: { type: Number },
-}, {
-    virtuals: [...addTagVirtuals('Question'), ...addApplicationVirtual()],
-});
-export const Rating = createModel('Rating', {
-    votes: [{ type: mongo.Schema.Types.ObjectId, ref: 'Vote' }],
-}, {
-    virtuals: [...addTagVirtuals('Rating'), ...addApplicationVirtual()],
-});
-export const Realm = createModel('Realm', {
-    endpoint: { type: String },
-    status: { type: String },
-    clientCount: { type: Number },
-    regionCode: { type: String },
-    gameId: { type: mongo.Schema.Types.ObjectId, ref: 'Game', required: true },
-}, {
-    virtuals: [
-        ...addTagVirtuals('Realm'),
-        ...addApplicationVirtual(),
-        { name: 'realmShards' },
-        { name: 'realmTraits' },
-        { name: 'realmEvents' },
-    ],
-});
-export const RealmEvent = createModel('RealmEvent', {
-    description: { type: String, required: true },
-    startDate: { type: Date, required: false },
-    endDate: { type: Date, required: false },
-}, {
-    virtuals: [...addTagVirtuals('RealmEvent'), ...addApplicationVirtual()],
-});
-export const RealmTrait = createModel('RealmTrait', {
-    description: { type: String, required: true },
-}, {
-    virtuals: [...addTagVirtuals('RealmTrait'), ...addApplicationVirtual()],
-});
-export const Referral = createModel('Referral', {
-    recipientId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: true },
-    senderId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: true },
-}, {
-    virtuals: [...addTagVirtuals('Referral'), ...addApplicationVirtual()],
-});
-export const Review = createModel('Review', {
-    value: { type: String },
-}, {
-    virtuals: [...addTagVirtuals('Review'), ...addApplicationVirtual()],
-});
-export const Role = createModel('Role', {
-    value: { type: String },
-    profiles: [{ type: mongo.Schema.Types.ObjectId, ref: 'Profile' }],
-    permissions: [{ type: mongo.Schema.Types.ObjectId, ref: 'Permission' }],
-}, {
-    virtuals: [...addTagVirtuals('Role'), ...addApplicationVirtual()],
-});
-export const Season = createModel('Season', {}, {
-    virtuals: [...addTagVirtuals('Season'), ...addApplicationVirtual()],
-});
-export const RealmShard = createModel('RealmShard', {
-    realmId: { type: mongo.Schema.Types.ObjectId, ref: 'Realm' },
-    endpoint: { type: String },
-    status: { type: String },
-    clientCount: { type: Number },
-}, {
-    virtuals: [...addTagVirtuals('RealmShard'), ...addApplicationVirtual()],
-});
-export const Session = createModel('Session', {
-    expired: { type: Date, required: true },
-}, {
-    virtuals: [...addTagVirtuals('Session'), ...addApplicationVirtual()],
-});
-export const SolarSystem = createModel('SolarSystem', {
-    galaxyId: { type: mongo.Schema.Types.ObjectId, ref: 'Galaxy' },
-}, {
-    virtuals: [...addTagVirtuals('SolarSystem'), ...addApplicationVirtual()],
-});
-export const Star = createModel('Star', {}, {
-    virtuals: [...addTagVirtuals('Star'), ...addApplicationVirtual()],
-});
-export const Stat = createModel('Stat', {
-    number: { type: Number, default: 0 },
-}, {
-    virtuals: [...addTagVirtuals('Stat'), ...addApplicationVirtual()],
-});
-export const Stash = createModel('Stash', {}, {
-    virtuals: [...addTagVirtuals('Stash'), ...addApplicationVirtual()],
-});
-export const Stock = createModel('Stock', {
-    rank: { type: Number, min: 0 },
-    price: { type: Number, min: 0 },
-    hourChange: { type: Number },
-    dayChange: { type: Number },
-    weekChange: { type: Number },
-    marketCap: { type: Number, min: 0 },
-    volume: { type: Number, min: 0 },
-    ticker: { type: String },
-    unusualActivity: { type: Number, min: 0 },
-}, {
-    virtuals: [...addTagVirtuals('Stock'), ...addApplicationVirtual()],
-});
-export const Suggestion = createModel('Suggestion', {
-    content: { type: String },
-}, {
-    virtuals: [...addTagVirtuals('Suggestion'), ...addApplicationVirtual()],
-});
-export const Tag = createModel('Tag', {
-    value: { type: String },
-}, {
-    virtuals: [...addApplicationVirtual()],
-});
-export const Team = createModel('Team', {
-    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
-    points: { type: Number, default: 0 },
-    memberCount: { type: Number, default: 0 },
-}, {
-    virtuals: [
-        ...addTagVirtuals('Team'),
-        ...addApplicationVirtual(),
-        {
-            name: 'profiles',
-            ref: 'Profile',
-            localField: '_id',
-            foreignField: 'teamId',
-        },
-    ],
-});
-export const Tournament = createModel('Tournament', {}, {
-    virtuals: [...addTagVirtuals('Tournament'), ...addApplicationVirtual()],
-});
-export const Trade = createModel('Trade', {
-    status: {
-        type: String,
-        default: 'Active',
-        enum: ['Paused', 'Pending', 'Active', 'Delisted', 'Sold'],
-    },
-    chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain' },
-    buyerId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' },
-    parentId: { type: mongo.Schema.Types.ObjectId, ref: 'Trade' },
-    productId: { type: mongo.Schema.Types.ObjectId, ref: 'Product' },
-    sellerId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' },
-    tokenId: { type: mongo.Schema.Types.ObjectId, ref: 'ChainToken' },
-}, {
-    virtuals: [...addTagVirtuals('Trade'), ...addApplicationVirtual()],
-});
-export const Universe = createModel('Universe', {}, {
-    virtuals: [...addTagVirtuals('Universe'), ...addApplicationVirtual()],
-});
-export const Validator = createModel('Validator', {}, {
-    virtuals: [...addTagVirtuals('Validator'), ...addApplicationVirtual()],
-});
-export const Vote = createModel('Vote', {
-    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
-}, {
-    virtuals: [
-        {
-            name: 'parent',
-            ref: 'Node',
-            localField: '_id',
-            foreignField: 'from',
-            justOne: true,
-            match: { fromModel: 'Vote' },
-        },
-        {
-            name: 'owner',
-            ref: 'Profile',
-            localField: '_id',
-            foreignField: '_id',
-            justOne: true,
-        },
-        ...addTagVirtuals('Vote'),
-        ...addApplicationVirtual(),
-    ],
-});
-export const WorldEvent = createModel('WorldEvent', {
-    text: { type: String, required: true },
-    importance: { type: Number },
-}, {
-    virtuals: [...addTagVirtuals('WorldEvent'), ...addApplicationVirtual()],
-});
-export const WorldRecord = createModel('WorldRecord', {
-    holderId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' },
-    score: { type: Number },
-}, {
-    virtuals: [
-        {
-            name: 'holder',
-            ref: 'Profile',
-            localField: '_id',
-            foreignField: '_id',
-            justOne: true,
-        },
-        ...addTagVirtuals('WorldRecord'),
-        ...addApplicationVirtual(),
-    ],
-});
-export const Node = createModel('Node', {
-    relationKey: { type: String, required: true },
-    fromModel: { type: String, required: true },
-    from: { type: mongo.Schema.Types.ObjectId, required: true },
-    toModel: { type: String, required: true },
-    to: { type: mongo.Schema.Types.ObjectId, required: true },
-}, {
-    indexes: [
-        { fromModel: 1, from: 1 },
-        { toModel: 1, to: 1 },
-    ],
-});
-export const Prefab = createModel('Prefab', {
-    name: { type: String, required: true },
-    fbxPath: { type: String, required: true },
-    customizationOptions: { type: mongo.Schema.Types.Mixed },
-    childPrefabs: [
-        {
-            prefabId: { type: mongo.Schema.Types.ObjectId, ref: 'Prefab' },
-            position: { type: mongo.Schema.Types.Mixed },
-            rotation: { type: mongo.Schema.Types.Mixed },
-            scale: { type: Number, default: 1.0 },
-        },
-    ],
-}, {
-    extend: 'EntityFields',
-    virtuals: [...addTagVirtuals('Prefab'), ...addApplicationVirtual()],
-});
-export const Object = createModel('Object', {
-    prefabId: { type: mongo.Schema.Types.ObjectId, ref: 'Prefab', required: true },
-    rotation: { type: mongo.Schema.Types.Mixed },
-    scale: { type: Number, default: 1.0 },
-    customizations: { type: mongo.Schema.Types.Mixed },
-    childInstances: [
-        {
-            prefabId: { type: mongo.Schema.Types.ObjectId, ref: 'Prefab' },
-            worldCoordinates: { type: mongo.Schema.Types.Mixed },
-            rotation: { type: mongo.Schema.Types.Mixed },
-            scale: { type: Number, default: 1.0 },
-        },
-    ],
-}, {
-    extend: 'EntityFields',
-    virtuals: [...addTagVirtuals('Object'), ...addApplicationVirtual()],
-});
-export const ObjectInteraction = createModel('ObjectInteraction', {
-    profileId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: true },
-    objectId: { type: mongo.Schema.Types.ObjectId, ref: 'Object', required: true },
-    interactionType: { type: String, enum: ['use', 'fight', 'open', 'talk'], required: true },
-    outcome: { type: mongo.Schema.Types.Mixed },
-}, {
-    extend: 'EntityFields',
-    virtuals: [...addTagVirtuals('Interaction'), ...addApplicationVirtual()],
-});
-export const Party = createModel('Party', {
-    targetAreaId: { type: mongo.Schema.Types.ObjectId, ref: 'Area', required: false },
-    limit: { type: Number, default: 6 },
-    isPublic: { type: Boolean, default: true },
-    isVisibleToEnemies: { type: Boolean, default: true },
-    isApprovalRequired: { type: Boolean, default: false },
-    isNonLeaderInviteAllowed: { type: Boolean, default: false },
-    isCombatEnabled: { type: Boolean, default: true },
-    isFriendlyFireEnabled: { type: Boolean, default: true },
-    isLocalQuestShared: { type: Boolean, default: true },
-    isGlobalQuestShared: { type: Boolean, default: true },
-    isMergeEnabled: { type: Boolean, default: false },
-    isRejoinEnabled: { type: Boolean, default: false },
-    itemDistribution: {
-        type: String,
-        enum: ['Random', 'Personal'],
-        required: true,
-    },
-    leaderId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile', required: false },
-    powerRequired: { type: Number, required: true, default: 1 },
-    levelRequired: { type: Number, required: true, default: 1 },
-    approvalMethod: {
-        type: String,
-        enum: ['Auto Accept', 'Approval Required'],
-        required: true,
-    },
-    memberIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'Profile' }],
-    assistantIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'Profile' }],
-    pendingMemberIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'Profile' }],
-    blockedMemberIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'Profile' }],
-}, {
-    virtuals: [
-        { name: 'owner' },
-        {
-            name: 'members',
-            ref: 'Profile',
-            localField: '_id',
-            foreignField: 'partyId',
-        },
-        ...addTagVirtuals('Party'),
-        ...addApplicationVirtual(),
-    ],
-});
-export const SeerEvent = mongo.createModel('SeerEvent', {
-    kind: { type: String, required: true },
-    operation: {
-        type: String,
-        enum: ['create', 'update', 'delete'],
-        required: true,
-    },
-    recordId: { type: String, required: true },
-    applicationId: { type: mongo.Schema.Types.ObjectId, ref: 'Application' },
-    payload: { type: mongo.Schema.Types.Mixed, required: true },
-    seq: { type: Number, required: true, index: true },
-    timestamp: { type: Date, default: Date.now, index: true },
-}, {
-    indexes: [{ seq: 1 }, { timestamp: 1 }],
-});
-export const SeerPayload = mongo.createModel('SeerPayload', {
-    fromSeer: { type: String, required: true },
-    applicationId: { type: mongo.Schema.Types.ObjectId, ref: 'Application' },
-    events: {
-        type: [mongo.Schema.Types.Mixed],
-        default: [],
-    },
-    eventsHash: { type: String, required: true },
-    merkleRoot: { type: String, required: true },
-    proof: { type: mongo.Schema.Types.Mixed, required: true },
-    publicSignals: { type: [String], default: [] },
-}, {
-    indexes: [{ createdDate: 1 }],
-});
-//# sourceMappingURL=core.models.js.map