@arken/seer-protocol 0.1.1 → 0.1.2

package/isles/isles.schema.ts

@@ -1 +1 @@
-import { z, ObjectId, Entity } from '@arken/schema';
+import { z, ObjectId, Entity } from '@arken/node/schema';

package/isles/isles.types.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Model, Document } from '@arken/mongo';
+import { Model, Document } from '@arken/node/mongo';
 import * as schema from './isles.schema';
 
 export type * from './isles.router';

package/item/index.ts

@@ -0,0 +1,5 @@
+export * as Types from './item.types';
+export * as Models from './item.models';
+export * as Schemas from './item.schema';
+export * from './item.router';
+export * from './item.service';

package/item/item.models.ts

@@ -0,0 +1,124 @@
+import * as mongo from '../../util/mongo';
+import type * as Types from './item.types';
+
+const { addTagVirtuals, addApplicationVirtual } = mongo;
+
+export const Item = mongo.createModel<Types.ItemDocument>(
+  'Item',
+  {
+    token: { type: String, maxlength: 500, minlength: 1, required: true },
+    characterId: { type: mongo.Schema.Types.ObjectId, ref: 'Character', required: true },
+    assetId: { type: mongo.Schema.Types.ObjectId, ref: 'Asset', required: true },
+    chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain', required: false },
+    materialId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemMaterial', required: false },
+    skinId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemSkin', required: false },
+    recipeId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemRecipe', required: false },
+    typeId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemType', required: false },
+    subTypeId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemSubType', required: false },
+    specificTypeId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemSpecificType', required: false },
+    rarityId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemRarity', required: false },
+    rankId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemRank', required: false },
+    rankValue: { type: Number, integer: true, min: 0, max: 100, required: false },
+    slotIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'ItemSlot', required: false }],
+    setId: { type: mongo.Schema.Types.ObjectId, ref: 'ItemSet', required: false },
+    attributes: [{ type: mongo.Schema.Types.ObjectId, ref: 'ItemAttribute', required: false }],
+    quantity: { type: Number, integer: true, min: 0, default: 1 },
+    distribution: { type: String, default: 'Unknown' },
+    x: { type: Number, integer: true, min: 0, required: false },
+    y: { type: Number, integer: true, min: 0, required: false },
+    items: [{ type: mongo.Schema.Types.ObjectId, ref: 'Item', default: [] }],
+    capacity: { type: Number, integer: true, min: 0, default: 60 },
+    points: { type: Number, integer: true, min: 0, default: 0 },
+  },
+  {
+    extend: 'EntityFields',
+    indexes: [{ quantity: 1 }, { points: 1 }, { capacity: 1 }],
+    virtuals: [
+      ...addTagVirtuals('Item'),
+      ...addApplicationVirtual(),
+      {
+        name: 'character',
+      },
+      {
+        name: 'asset',
+      },
+      {
+        name: 'chain',
+      },
+      {
+        name: 'material',
+      },
+      {
+        name: 'skin',
+      },
+      {
+        name: 'recipe',
+      },
+      {
+        name: 'type',
+      },
+      {
+        name: 'subType',
+      },
+      {
+        name: 'specificType',
+      },
+      {
+        name: 'rarity',
+      },
+    ],
+  }
+);
+
+export const ItemAttribute = mongo.createModel<Types.ItemAttributeDocument>('ItemAttribute', {});
+
+export const ItemMaterial = mongo.createModel<Types.ItemMaterialDocument>('ItemMaterial', {});
+
+export const ItemSet = mongo.createModel<Types.ItemSetDocument>('ItemSet', {});
+
+export const ItemSlot = mongo.createModel<Types.ItemSlotDocument>('ItemSlot', {});
+
+export const ItemRarity = mongo.createModel<Types.ItemRarityDocument>('ItemRarity', {});
+
+export const ItemRank = mongo.createModel<Types.ItemRankDocument>('ItemRank', {
+  value: { type: Number },
+});
+
+export const ItemType = mongo.createModel<Types.ItemTypeDocument>('ItemType', {});
+
+export const ItemSubType = mongo.createModel<Types.ItemSubTypeDocument>('ItemSubType', {});
+
+export const ItemSpecificType = mongo.createModel<Types.ItemSpecificTypeDocument>('ItemSpecificType', {});
+
+export const ItemAffix = mongo.createModel<Types.ItemAffixDocument>('ItemAffix', {
+  isPrefix: { type: Boolean, default: false },
+  isSuffix: { type: Boolean, default: false },
+  isTitle: { type: Boolean, default: false },
+  weight: { type: Number, min: 0, default: 1 },
+  typeIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'ItemType', required: false }],
+  rarityIds: [{ type: mongo.Schema.Types.ObjectId, ref: 'ItemRarity', required: false }],
+});
+
+export const ItemRecipe = mongo.createModel<Types.ItemRecipeDocument>('ItemRecipe', {});
+
+export const ItemSkin = mongo.createModel<Types.ItemSkinDocument>('ItemSkin', {});
+
+export const ItemTransmute = mongo.createModel<Types.ItemTransmuteDocument>(
+  'ItemTransmute',
+  {
+    token: { type: String, maxlength: 500, required: true },
+    assetId: { type: mongo.Schema.Types.ObjectId, ref: 'Asset', required: true },
+    itemId: { type: mongo.Schema.Types.ObjectId, ref: 'Item', required: true },
+    chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain' },
+  },
+  {
+    virtuals: [
+      {
+        name: 'item',
+      },
+      {
+        name: 'asset',
+      },
+    ],
+  }
+);

package/item/item.router.ts

@@ -0,0 +1,103 @@
+import { z as zod } from 'zod';
+import { initTRPC } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '../../util/rpc';
+import type { RouterContext } from '../../types';
+import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '../../schema';
+import {
+  Item,
+  ItemAttribute,
+  ItemMaterial,
+  ItemSet,
+  ItemSlot,
+  ItemRarity,
+  ItemType,
+  ItemSubType,
+  ItemSpecificType,
+  ItemAffix,
+  ItemRecipe,
+  ItemSkin,
+  ItemTransmute,
+} from './item.schema';
+
+export const z = zod;
+export const t = initTRPC.context<RouterContext>().create();
+export const router = t.router;
+export const procedure = t.procedure;
+
+export const createRouter = () =>
+  router({
+    getItem: procedure
+      .use(hasRole('guest', t))
+      .input(getQueryInput(Item))
+      .output(Item)
+      .query(({ input, ctx }) => (ctx.app.service.Item.getItem as any)(input, ctx)),
+
+    getItems: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Item))
+      // .output(z.array(Item))
+      .query(({ input, ctx }) => (ctx.app.service.Item.getItems as any)(input, ctx)),
+
+    createItem: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Item))
+      .output(Item.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Item.createItem as any)(input, ctx)),
+
+    updateItem: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Item))
+      .output(Item.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Item.updateItem as any)(input, ctx)),
+
+    getItemAttribute: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ItemAttribute))
+      .output(ItemAttribute)
+      .query(({ input, ctx }) => (ctx.app.service.Item.getItemAttribute as any)(input, ctx)),
+
+    createItemAttribute: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ItemAttribute))
+      .output(ItemAttribute.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Item.createItemAttribute as any)(input, ctx)),
+
+    updateItemAttribute: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ItemAttribute))
+      .output(ItemAttribute.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Item.updateItemAttribute as any)(input, ctx)),
+
+    // Add more procedures for other entities like ItemMaterial, ItemSet, ItemSlot, ItemRarity, etc.
+
+    getItemTransmute: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ItemTransmute))
+      .output(ItemTransmute)
+      .query(({ input, ctx }) => (ctx.app.service.Item.getItemTransmute as any)(input, ctx)),
+
+    createItemTransmute: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ItemTransmute))
+      .output(ItemTransmute.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Item.createItemTransmute as any)(input, ctx)),
+
+    updateItemTransmute: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ItemTransmute))
+      .output(ItemTransmute.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Item.updateItemTransmute as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/item/item.schema.ts

@@ -0,0 +1,120 @@
+import { z, ObjectId, Entity } from '../../schema';
+
+export const ItemAttribute = Entity.merge(
+  z.object({
+    // Define fields for ItemAttribute here if needed
+  })
+);
+
+export const ItemMaterial = Entity.merge(
+  z.object({
+    // Define fields for ItemMaterial here if needed
+  })
+);
+
+export const ItemSet = Entity.merge(
+  z.object({
+    // Define fields for ItemSet here if needed
+  })
+);
+
+export const ItemSlot = Entity.merge(
+  z.object({
+    // Define fields for ItemSlot here if needed
+  })
+);
+
+export const ItemRarity = Entity.merge(
+  z.object({
+    // Define fields for ItemRarity here if needed
+  })
+);
+
+export const ItemRank = Entity.merge(
+  z.object({
+    value: z.number(),
+    // Define fields for ItemRank here if needed
+  })
+);
+
+export const ItemType = Entity.merge(
+  z.object({
+    // Define fields for ItemType here if needed
+  })
+);
+
+export const ItemSubType = Entity.merge(
+  z.object({
+    // Define fields for ItemSubType here if needed
+  })
+);
+
+export const ItemSpecificType = Entity.merge(
+  z.object({
+    // Define fields for ItemSpecificType here if needed
+  })
+);
+
+export const ItemAffix = Entity.merge(
+  z.object({
+    isPrefix: z.boolean().default(false),
+    isSuffix: z.boolean().default(false),
+    isTitle: z.boolean().default(false),
+    weight: z.number().min(0).default(1),
+    typeIds: z.array(ObjectId).optional(),
+    rarityIds: z.array(ObjectId).optional(),
+  })
+);
+
+export const ItemRecipe = Entity.merge(
+  z.object({
+    // Define fields for ItemRecipe here if needed
+  })
+);
+
+export const ItemSkin = Entity.merge(
+  z.object({
+    // Define fields for ItemSkin here if needed
+  })
+);
+
+export const ItemTransmute = Entity.merge(
+  z.object({
+    token: z.string().max(500).min(1),
+    assetId: ObjectId,
+    itemId: ObjectId,
+    chainId: ObjectId.optional(),
+  })
+);
+
+export const Item = Entity.merge(
+  z.object({
+    characterId: ObjectId.optional(),
+    assetId: ObjectId.optional(),
+    chainId: ObjectId.optional(),
+    materialId: ItemMaterial.optional(),
+    skinId: ItemSkin.optional(),
+    recipeId: ItemRecipe.optional(),
+    typeId: ItemType.optional(),
+    subTypeId: ItemSubType.optional(),
+    specificTypeId: ItemSpecificType.optional(),
+    rankId: ItemRank.optional(),
+    rankValue: z.number(),
+    rarityId: ItemRarity.optional(),
+    slotIds: z.array(ItemSlot.optional()),
+    setId: ItemSet.optional(),
+    attributes: z.array(ItemAttribute).optional(),
+    token: z.string().max(500).min(1).optional(),
+    quantity: z.number().int().nonnegative().default(1),
+    x: z.number().int().nonnegative().optional(),
+    y: z.number().int().nonnegative().optional(),
+    distribution: z
+      .enum(['Unknown', 'Found', 'Fundraiser', 'Claimed', 'Crafted', 'Airdrop', 'Reward', 'Farmed', 'Migration'])
+      .default('Unknown'),
+    // properties: z.record(z.any()).optional(),
+    // type: z.string().default('bag'), // stash, bag, equipment, etc.
+    items: z.array(z.lazy(() => Item)).default([]),
+    capacity: z.number().int().nonnegative().default(60),
+    points: z.number().int().nonnegative().default(0),
+  })
+);

package/item/item.types.ts

@@ -0,0 +1,74 @@
+// module/item.types.ts
+
+import { z } from 'zod';
+import * as schema from './item.schema';
+import { Document, Model } from '../../util/mongo';
+import type { RouterContext } from '../../types';
+import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import type { Router } from './item.router';
+
+export type * from './item.router';
+export type * from './item.service';
+export type { RouterContext };
+
+export type Item = z.infer<typeof schema.Item>;
+export type ItemDocument = Item & Document;
+
+export type ItemAttribute = z.infer<typeof schema.ItemAttribute>;
+export type ItemAttributeDocument = ItemAttribute & Document;
+
+export type ItemMaterial = z.infer<typeof schema.ItemMaterial>;
+export type ItemMaterialDocument = ItemMaterial & Document;
+
+export type ItemSet = z.infer<typeof schema.ItemSet>;
+export type ItemSetDocument = ItemSet & Document;
+
+export type ItemSlot = z.infer<typeof schema.ItemSlot>;
+export type ItemSlotDocument = ItemSlot & Document;
+
+export type ItemRarity = z.infer<typeof schema.ItemRarity>;
+export type ItemRarityDocument = ItemRarity & Document;
+
+export type ItemRank = z.infer<typeof schema.ItemRank>;
+export type ItemRankDocument = ItemRank & Document;
+
+export type ItemType = z.infer<typeof schema.ItemType>;
+export type ItemTypeDocument = ItemType & Document;
+
+export type ItemSubType = z.infer<typeof schema.ItemSubType>;
+export type ItemSubTypeDocument = ItemSubType & Document;
+
+export type ItemSpecificType = z.infer<typeof schema.ItemSpecificType>;
+export type ItemSpecificTypeDocument = ItemSpecificType & Document;
+
+export type ItemAffix = z.infer<typeof schema.ItemAffix>;
+export type ItemAffixDocument = ItemAffix & Document;
+
+export type ItemRecipe = z.infer<typeof schema.ItemRecipe>;
+export type ItemRecipeDocument = ItemRecipe & Document;
+
+export type ItemSkin = z.infer<typeof schema.ItemSkin>;
+export type ItemSkinDocument = ItemSkin & Document;
+
+export type ItemTransmute = z.infer<typeof schema.ItemTransmute>;
+export type ItemTransmuteDocument = ItemTransmute & Document;
+
+export type Mappings = {
+  Item: Model<ItemDocument>;
+  ItemAttribute: Model<ItemAttributeDocument>;
+  ItemMaterial: Model<ItemMaterialDocument>;
+  ItemSet: Model<ItemSetDocument>;
+  ItemSlot: Model<ItemSlotDocument>;
+  ItemRarity: Model<ItemRarityDocument>;
+  ItemRank: Model<ItemRankDocument>;
+  ItemType: Model<ItemTypeDocument>;
+  ItemSubType: Model<ItemSubTypeDocument>;
+  ItemSpecificType: Model<ItemSpecificTypeDocument>;
+  ItemAffix: Model<ItemAffixDocument>;
+  ItemRecipe: Model<ItemRecipeDocument>;
+  ItemSkin: Model<ItemSkinDocument>;
+  ItemTransmute: Model<ItemTransmuteDocument>;
+};
+
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/job/index.ts

@@ -0,0 +1,5 @@
+export * as Types from './job.types';
+export * as Models from './job.models';
+export * as Schemas from './job.schema';
+export * from './job.router';
+export * from './job.service';

package/job/job.models.ts

@@ -0,0 +1,14 @@
+import * as mongo from '../../util/mongo';
+import type * as Types from './job.types';
+
+export const Job = mongo.createModel<Types.JobDocument>(
+  'Job',
+  {
+    mod: { type: String, required: true },
+    startDate: { type: Date },
+    expireDate: { type: Date },
+  },
+  {
+    indexes: [{ applicationId: 1, mod: 1, key: 1 }],
+  }
+);

package/job/job.router.ts

@@ -0,0 +1,44 @@
+// job.router.ts
+
+import { z as zod } from 'zod';
+import { initTRPC, inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '../../util/rpc';
+import type { RouterContext } from '../../types';
+import { Job } from './job.schema';
+import { Query } from '../../schema';
+
+export const z = zod;
+export const t = initTRPC.context<RouterContext>().create();
+export const router = t.router;
+export const procedure = t.procedure;
+
+export const createRouter = () =>
+  router({
+    getJob: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Job.getJob as any)(input, ctx)),
+
+    createJob: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: Job }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Job.createJob as any)(input, ctx)),
+
+    updateJob: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: Job.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Job.updateJob as any)(input, ctx)),
+
+    updateMetrics: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.any())
+      .mutation(({ input, ctx }) => (ctx.app.service.Job.updateMetrics as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/job/job.schema.ts

@@ -0,0 +1,9 @@
+import { z, ObjectId, Entity } from '../../schema';
+
+export const Job = Entity.merge(
+  z.object({
+    mod: z.string(),
+    startDate: z.date().optional(),
+    expireDate: z.date().optional(),
+  })
+);

package/job/job.types.ts

@@ -0,0 +1,23 @@
+// module/job.types.ts
+
+import { z } from 'zod';
+import * as schema from './job.schema';
+import { Document, Model } from '../../util/mongo';
+import type { RouterContext } from '../../types';
+import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import type { Router } from './job.router';
+
+export type * from './job.router';
+export type * from './job.service';
+export type { RouterContext };
+
+export type Job = z.infer<typeof schema.Job>;
+
+export type JobDocument = Job & Document;
+
+export type Mappings = {
+  Job: Model<JobDocument>;
+};
+
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/market/index.ts

@@ -0,0 +1,5 @@
+export * as Types from './market.types';
+export * as Models from './market.models';
+export * as Schemas from './market.schema';
+export * from './market.router';
+export * from './market.service';

package/market/market.models.ts

@@ -0,0 +1,113 @@
+import * as mongo from '../../util/mongo';
+import type * as Types from './market.types';
+
+export const Market = mongo.createModel<Types.MarketDocument>('Market', {
+  value: { type: String, required: true },
+});
+
+export const MarketPair = mongo.createModel<Types.MarketPairDocument>('MarketPair', {
+  value: { type: String, required: true },
+});
+
+export const MarketExchange = mongo.createModel<Types.MarketExchangeDocument>('MarketExchange', {
+  value: { type: String },
+});
+
+export const MarketAnalysis = mongo.createModel<Types.MarketAnalysisDocument>('MarketAnalysis', {
+  action: { type: String, required: true },
+  asset: { type: String, required: true },
+  signalType: { type: String, required: true },
+  confidence: { type: Number, required: true },
+  riskLevel: { type: String, required: true },
+  timeFrame: { type: String, required: true },
+  source: { type: String, required: true },
+  summary: { type: String, required: true },
+  labels: {
+    sector: { type: String },
+    topic: { type: String },
+    sentiment: { type: String },
+  },
+});
+
+export const MarketInvestor = mongo.createModel<Types.MarketInvestorDocument>('MarketInvestor', {
+  portfolioIds: [{ type: mongo.Schema.Types.ObjectId, required: true }],
+  totalPnl: { type: Number },
+});
+
+export const MarketInvestmentPortfolio = mongo.createModel<Types.MarketInvestmentPortfolioDocument>(
+  'MarketInvestmentPortfolio',
+  {
+    categoryGoals: [
+      {
+        category: { type: String, required: true },
+        goalPercentage: { type: Number, required: true },
+        currentPnL: { type: Number },
+        historicalPnL: { type: Number },
+      },
+    ],
+    investmentIds: [{ type: mongo.Schema.Types.ObjectId, required: true }],
+    totalPnl: { type: Number },
+  }
+);
+
+export const MarketInvestment = mongo.createModel<Types.MarketInvestmentDocument>('MarketInvestment', {
+  type: { type: String, required: true },
+  amount: { type: Number, required: true },
+  category: { type: String, required: true },
+  purchasePrice: { type: Number, required: true },
+  currentValue: { type: Number, required: true },
+  pnl: { type: Number, required: true },
+  transactions: [
+    {
+      date: { type: Date, required: true },
+      type: { type: String, required: true },
+      price: { type: Number, required: true },
+      quantity: { type: Number, required: true },
+    },
+  ],
+  stockId: { type: mongo.Schema.Types.ObjectId },
+  chainTokenId: { type: mongo.Schema.Types.ObjectId },
+});
+
+export const MarketStock = mongo.createModel<Types.MarketStockDocument>('MarketStock', {
+  ticker: { type: String, required: true },
+  companyId: { type: mongo.Schema.Types.ObjectId, required: true, ref: 'StockCompany' },
+  currentPrice: { type: Number, required: true },
+  marketCap: { type: Number },
+  volume: { type: Number },
+  currency: { type: String, required: true },
+  aum: { type: Number },
+  quoteType: { type: String },
+  dailyChange: { type: Number },
+  dailyChangePercent: { type: Number },
+});
+
+export const MarketToken = mongo.createModel<Types.MarketTokenDocument>('MarketToken', {
+  symbol: { type: String, required: true },
+  currentPrice: { type: Number, required: true },
+});
+
+export const MarketCompany = mongo.createModel<Types.MarketCompanyDocument>('MarketCompany', {
+  ticker: { type: String, required: true },
+  country: { type: String, required: true },
+  industry: { type: String, required: true },
+  sector: { type: String, required: true },
+  type: { type: String, required: true },
+  issuedETFs: [{ type: mongo.Schema.Types.ObjectId, ref: 'MarketETF' }],
+});
+
+export const MarketETF = mongo.createModel<Types.MarketETFDocument>('ETF', {
+  ticker: { type: String, required: true },
+  issuerId: { type: mongo.Schema.Types.ObjectId, required: true },
+  leverage: { type: Number, required: false },
+});
+
+export const MarketStockSentiment = mongo.createModel<Types.MarketStockSentimentDocument>('MarketStockSentiment', {
+  ticker: { type: String, required: true },
+  companyId: { type: mongo.Schema.Types.ObjectId, required: true, ref: 'StockCompany' },
+  sentiment: {
+    label: { type: String, required: true },
+    score: { type: Number, required: true },
+  },
+  confidence: { type: Number, required: true },
+});