@arken/seer-protocol 0.1.4 → 0.1.5

package/build/core/core.models.js

@@ -0,0 +1,811 @@
+import * as mongo from '@arken/node/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