@arken/seer-protocol 0.1.0 → 0.1.2

package/raffle/raffle.models.ts

@@ -0,0 +1,44 @@
+import * as mongo from '../../util/mongo';
+import type * as Types from './raffle.types';
+
+export const Raffle = mongo.createModel<Types.RaffleDocument>(
+  'Raffle',
+  {
+    content: { type: String, required: true },
+    rewards: [{ type: mongo.Schema.Types.ObjectId, ref: 'RaffleReward' }],
+  },
+  {
+    virtuals: [
+      {
+        name: 'raffleRequirements',
+        ref: 'RaffleRequirement',
+        localField: '_id',
+        foreignField: 'raffleId',
+      },
+      {
+        name: 'raffleEntries',
+        ref: 'RaffleEntry',
+        localField: '_id',
+        foreignField: 'raffleId',
+      },
+    ],
+  }
+);
+
+export const RaffleRequirement = mongo.createModel<Types.RaffleRequirementDocument>('RaffleRequirement', {
+  amount: { type: Number, required: true },
+  raffleRewardId: { type: mongo.Schema.Types.ObjectId, ref: 'RaffleReward' },
+});
+
+export const RaffleReward = mongo.createModel<Types.RaffleRewardDocument>('RaffleReward', {
+  raffleId: { type: mongo.Schema.Types.ObjectId, ref: 'Raffle' },
+  winnerId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' },
+  requirements: [{ type: mongo.Schema.Types.ObjectId, ref: 'RaffleRequirement' }],
+  entries: [{ type: mongo.Schema.Types.ObjectId, ref: 'RaffleEntry' }],
+});
+
+export const RaffleEntry = mongo.createModel<Types.RaffleEntryDocument>('RaffleEntry', {
+  amount: { type: Number, required: true },
+  raffleRewardId: { type: mongo.Schema.Types.ObjectId, ref: 'RaffleReward' },
+  raffleId: { type: mongo.Schema.Types.ObjectId, ref: 'Raffle' },
+});

package/raffle/raffle.router.ts

@@ -0,0 +1,90 @@
+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 { Raffle, RaffleRequirement, RaffleReward, RaffleEntry } from './raffle.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({
+    // Raffle endpoints
+    getRaffle: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Raffle.getRaffle as any)(input, ctx)),
+
+    createRaffle: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(Raffle)
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.createRaffle as any)(input, ctx)),
+
+    updateRaffle: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleId: z.string(), data: Raffle.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.updateRaffle as any)(input, ctx)),
+
+    getRaffleRequirement: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleRequirementId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Raffle.getRaffleRequirement as any)(input, ctx)),
+
+    createRaffleRequirement: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(RaffleRequirement)
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.createRaffleRequirement as any)(input, ctx)),
+
+    updateRaffleRequirement: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleRequirementId: z.string(), data: RaffleRequirement.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.updateRaffleRequirement as any)(input, ctx)),
+
+    getRaffleReward: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleRewardId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Raffle.getRaffleReward as any)(input, ctx)),
+
+    createRaffleReward: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(RaffleReward)
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.createRaffleReward as any)(input, ctx)),
+
+    updateRaffleReward: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleRewardId: z.string(), data: RaffleReward.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.updateRaffleReward as any)(input, ctx)),
+
+    getRaffleEntry: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleEntryId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Raffle.getRaffleEntry as any)(input, ctx)),
+
+    createRaffleEntry: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(RaffleEntry)
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.createRaffleEntry as any)(input, ctx)),
+
+    updateRaffleEntry: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ raffleEntryId: z.string(), data: RaffleEntry.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Raffle.updateRaffleEntry as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/raffle/raffle.schema.ts

@@ -0,0 +1,32 @@
+import { z, ObjectId, Entity } from '../../schema';
+
+export const Raffle = Entity.merge(
+  z.object({
+    content: z.string().min(1),
+    rewards: z.array(ObjectId).optional(), // List of reward IDs
+  })
+);
+
+export const RaffleRequirement = Entity.merge(
+  z.object({
+    amount: z.number().min(1),
+    raffleRewardId: ObjectId.optional(), // Reference to the associated RaffleReward
+  })
+);
+
+export const RaffleReward = Entity.merge(
+  z.object({
+    raffleId: ObjectId.optional(), // Reference to the associated Raffle
+    winnerId: ObjectId.optional(), // Reference to the winning Profile
+    requirements: z.array(ObjectId).optional(), // List of associated RaffleRequirement IDs
+    entries: z.array(ObjectId).optional(), // List of associated RaffleEntry IDs
+  })
+);
+
+export const RaffleEntry = Entity.merge(
+  z.object({
+    amount: z.number().min(1),
+    raffleRewardId: ObjectId.optional(), // Reference to the associated RaffleReward
+    raffleId: ObjectId.optional(), // Reference to the associated Raffle
+  })
+);

package/raffle/raffle.types.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import * as schema from './raffle.schema';
+import { Document, Model } from '../../util/mongo';
+import type { RouterContext } from '../../types';
+import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import type { Router } from './raffle.router';
+
+export type * from './raffle.router';
+export type * from './raffle.service';
+export type { RouterContext };
+
+export type Raffle = z.infer<typeof schema.Raffle>;
+export type RaffleRequirement = z.infer<typeof schema.RaffleRequirement>;
+export type RaffleReward = z.infer<typeof schema.RaffleReward>;
+export type RaffleEntry = z.infer<typeof schema.RaffleEntry>;
+
+export type RaffleDocument = Raffle & Document;
+export type RaffleRequirementDocument = RaffleRequirement & Document;
+export type RaffleRewardDocument = RaffleReward & Document;
+export type RaffleEntryDocument = RaffleEntry & Document;
+
+export type Mappings = {
+  Raffle: Model<RaffleDocument>;
+  RaffleRequirement: Model<RaffleRequirementDocument>;
+  RaffleReward: Model<RaffleRewardDocument>;
+  RaffleEntry: Model<RaffleEntryDocument>;
+};
+
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/{src/router.ts → router.ts}

@@ -1,34 +1,28 @@
-import util from '@arken/node/util';
 import { initTRPC } from '@trpc/server';
-import { observable } from '@trpc/server/observable';
-import { serialize, deserialize } from '@arken/node/util/rpc';
 import { z } from 'zod';
-import { customErrorFormatter, hasRole } from '@arken/node/util/rpc';
-import { Query, getQueryInput, getQueryOutput, inferRouterOutputs } from '@arken/node/schema';
-import * as Arken from '@arken/node/types';
 import * as Schema from '@arken/node/schema';
-import * as Area from '@arken/node/modules/area/area.router';
-import * as Asset from '@arken/node/modules/asset/asset.router';
-import * as Character from '@arken/node/modules/character/character.router';
-import * as Chain from '@arken/node/modules/chain/chain.router';
-import * as Chat from '@arken/node/modules/chat/chat.router';
-import * as Collection from '@arken/node/modules/collection/collection.router';
-import * as Core from '@arken/node/modules/core/core.router';
-import * as Game from '@arken/node/modules/game/game.router';
-import * as Interface from '@arken/node/modules/interface/interface.router';
-import * as Item from '@arken/node/modules/item/item.router';
-import * as Job from '@arken/node/modules/job/job.router';
-import * as Market from '@arken/node/modules/market/market.router';
-import * as Product from '@arken/node/modules/product/product.router';
-import * as Profile from '@arken/node/modules/profile/profile.router';
-import * as Raffle from '@arken/node/modules/raffle/raffle.router';
-import * as Skill from '@arken/node/modules/skill/skill.router';
-import * as Video from '@arken/node/modules/video/video.router';
-import * as Trek from './modules/trek/trek.router';
-import * as Isles from './modules/isles/isles.router';
-import * as Evolution from './modules/evolution/evolution.router';
-import * as Infinite from './modules/infinite/infinite.router';
-import * as Oasis from './modules/oasis/oasis.router';
+import * as Area from './area/area.router';
+import * as Asset from './asset/asset.router';
+import * as Character from './character/character.router';
+import * as Chain from './chain/chain.router';
+import * as Chat from './chat/chat.router';
+import * as Collection from './collection/collection.router';
+import * as Core from './core/core.router';
+import * as Game from './game/game.router';
+import * as Interface from './interface/interface.router';
+import * as Item from './item/item.router';
+import * as Job from './job/job.router';
+import * as Market from './market/market.router';
+import * as Product from './product/product.router';
+import * as Profile from './profile/profile.router';
+import * as Raffle from './raffle/raffle.router';
+import * as Skill from './skill/skill.router';
+import * as Video from './video/video.router';
+import * as Trek from './trek/trek.router';
+import * as Isles from './isles/isles.router';
+import * as Evolution from './evolution/evolution.router';
+import * as Infinite from './infinite/infinite.router';
+import * as Oasis from './oasis/oasis.router';
 import type * as Types from './types';
 
 export type RouterContext = {

package/schema.ts

@@ -0,0 +1,321 @@
+// arken/packages/node/schema.ts
+//
+import Mongoose, { Types } from 'mongoose';
+import { z as zod, ZodTypeAny, ZodLazy, ZodObject, ZodArray } from 'zod';
+import { AnyProcedure, inferProcedureOutput, AnyRouter, AnyTRPCClientTypes, TRPCRouterRecord } from '@trpc/server';
+
+export type { inferRouterInputs } from '@trpc/server';
+
+export const z = zod;
+
+// @ts-ignore
+export const ObjectId = z.union([
+  z.string().refine((value) => Mongoose.isValidObjectId(value), {
+    // Accept valid ObjectId strings
+    message: 'Invalid ObjectId',
+  }),
+  z.instanceof(Types.ObjectId), // Accept Mongoose ObjectId instances
+]);
+
+export const Anything = z.any();
+export const Nothing = z.object({});
+export const Signature = z.object({ hash: z.string(), address: z.string() });
+export const UnsignedData = z.object({ data: z.any() });
+export const SignedData = z.object({
+  data: z.any(),
+  signature: Signature,
+});
+
+export const AnyInput = z.any();
+export const OnlySignatureInput = z.object({ signature: Signature });
+export const NoDataOutput = z.object({ status: z.number() });
+export const AnyDataOutput = z.object({ data: z.any(), status: z.number() });
+
+export enum Status {
+  Paused = 'Paused',
+  Pending = 'Pending',
+  Active = 'Active',
+  Archived = 'Archived',
+}
+
+export type Meta = {
+  [key: string]: unknown;
+};
+
+export const Common = z.object({
+  id: ObjectId.optional(),
+  meta: z.any(), // Default value set here matches Mongoose
+  data: z.any(), // Default value set here matches Mongoose
+  status: z.enum(['Paused', 'Pending', 'Active', 'Archived']).default('Active'), // Default set in StatusEnum matches Mongoose
+  merkleLeaf: z.string().optional(),
+  merkleIndex: z.number().optional(),
+  createdById: ObjectId.optional(),
+  editedById: ObjectId.optional(),
+  deletedById: ObjectId.optional(),
+  createdDate: z.date().default(() => new Date()), // Default matches Mongoose
+  updatedDate: z.date().optional(),
+  deletedDate: z.date().optional(),
+});
+
+export type Common = zod.infer<typeof Common>;
+
+export const Entity = z
+  .object({
+    id: z.string().min(24).max(24).trim().optional(),
+    key: z.string().min(1).max(200).trim().optional(),
+    name: z.string().min(1).max(200).trim().optional(),
+    description: z.string().optional(),
+    applicationId: ObjectId.optional(),
+    ownerId: ObjectId.optional(),
+  })
+  .merge(Common);
+
+export type Entity = zod.infer<typeof Entity>;
+
+const QueryFilterOperators = z.object({
+  equals: z.any().optional(),
+  not: z.any().optional(),
+  in: z.array(z.any()).optional(),
+  notIn: z.array(z.any()).optional(),
+  lt: z.any().optional(),
+  lte: z.any().optional(),
+  gt: z.any().optional(),
+  gte: z.any().optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional(),
+  mode: z.enum(['default', 'insensitive']).optional(),
+});
+
+const QueryWhereSchema = z.lazy(() =>
+  z.object({
+    AND: z.array(QueryWhereSchema).optional(),
+    OR: z.array(QueryWhereSchema).optional(),
+    NOT: z.array(QueryWhereSchema).optional(),
+    id: QueryFilterOperators.optional(),
+    key: QueryFilterOperators.optional(),
+    name: QueryFilterOperators.optional(),
+    email: QueryFilterOperators.optional(),
+    status: QueryFilterOperators.optional(),
+  })
+);
+
+export const Query = z.object({
+  skip: z.number().default(0).optional(),
+  take: z.number().default(10).optional(),
+  cursor: z.record(z.any()).optional(),
+  where: QueryWhereSchema.optional(),
+  orderBy: z.record(z.enum(['asc', 'desc'])).optional(),
+  include: z.record(z.boolean()).optional(),
+  select: z.record(z.boolean()).optional(),
+});
+
+// // Operators for filtering in a Prisma-like way
+// type PrismaFilterOperators<T extends ZodTypeAny> = zod.ZodObject<
+//   {
+//     equals?: T;
+//     not?: T;
+//     in?: zod.ZodArray<T>;
+//     notIn?: zod.ZodArray<T>;
+//     lt?: T;
+//     lte?: T;
+//     gt?: T;
+//     gte?: T;
+//     contains?: zod.ZodString; // T extends zod.ZodString ? zod.ZodString : never;
+//     startsWith?: zod.ZodString; // T extends zod.ZodString ? zod.ZodString : never;
+//     endsWith?: zod.ZodString; // T extends zod.ZodString ? zod.ZodString : never;
+//     mode?: zod.ZodString; // T extends zod.ZodString ? zod.ZodEnum<['default', 'insensitive']> : never;
+//   },
+//   'strip',
+//   ZodTypeAny
+// >;
+
+// // Level 0: No AND, OR, NOT
+// type PrismaWhereLevel0<T extends zod.ZodRawShape> = ZodObject<
+//   {
+//     [K in keyof T]?: PrismaFilterOperators<T[K]>;
+//   },
+//   'strip',
+//   ZodTypeAny
+// >;
+
+// // Level 1: Includes AND, OR, NOT of Level 0
+// type PrismaWhereLevel1<T extends zod.ZodRawShape> = ZodObject<
+//   {
+//     AND?: ZodArray<ZodLazy<PrismaWhereLevel0<T>>>;
+//     OR?: ZodArray<ZodLazy<PrismaWhereLevel0<T>>>;
+//     NOT?: ZodArray<ZodLazy<PrismaWhereLevel0<T>>>;
+//   } & {
+//     [K in keyof T]?: PrismaFilterOperators<T[K]>;
+//   },
+//   'strip',
+//   ZodTypeAny
+// >;
+
+// // Level 2: Includes AND, OR, NOT of Level 1
+// type PrismaWhereLevel2<T extends zod.ZodRawShape> = ZodObject<
+//   {
+//     AND?: ZodArray<ZodLazy<PrismaWhereLevel1<T>>>;
+//     OR?: ZodArray<ZodLazy<PrismaWhereLevel1<T>>>;
+//     NOT?: ZodArray<ZodLazy<PrismaWhereLevel1<T>>>;
+//   } & {
+//     [K in keyof T]?: PrismaFilterOperators<T[K]>;
+//   },
+//   'strip',
+//   ZodTypeAny
+// >;
+
+// // Level 3: Includes AND, OR, NOT of Level 2
+// type PrismaWhereLevel3<T extends zod.ZodRawShape> = ZodObject<
+//   {
+//     AND?: ZodArray<ZodLazy<PrismaWhereLevel2<T>>>;
+//     OR?: ZodArray<ZodLazy<PrismaWhereLevel2<T>>>;
+//     NOT?: ZodArray<ZodLazy<PrismaWhereLevel2<T>>>;
+//   } & {
+//     [K in keyof T]?: PrismaFilterOperators<T[K]>;
+//   },
+//   'strip',
+//   ZodTypeAny
+// >;
+
+// // Level 4: Includes AND, OR, NOT of Level 3
+// type PrismaWhereLevel4<T extends zod.ZodRawShape> = ZodObject<
+//   {
+//     AND?: ZodArray<ZodLazy<PrismaWhereLevel3<T>>>;
+//     OR?: ZodArray<ZodLazy<PrismaWhereLevel3<T>>>;
+//     NOT?: ZodArray<ZodLazy<PrismaWhereLevel3<T>>>;
+//   } & {
+//     [K in keyof T]?: PrismaFilterOperators<T[K]>;
+//   },
+//   'strip',
+//   ZodTypeAny
+// >;
+
+// Function to create a recursive schema up to level 4
+export const createPrismaWhereSchema = <T extends zod.ZodRawShape>(
+  modelSchema: zod.ZodObject<T>,
+  depth: number = 3
+): zod.ZodObject<any> => {
+  const fields = modelSchema.shape;
+
+  /**
+   * For each field, accept either:
+   *   - a full operator object: { equals, in, lt, ... }
+   *   - OR a raw value shorthand: 'foo'  -> { equals: 'foo' }
+   */
+  const makeFieldFilter = (value: zod.ZodTypeAny) => {
+    const opsSchema = zod
+      .object({
+        equals: value.optional(),
+        not: value.optional(),
+        in: zod.array(value).optional(),
+        notIn: zod.array(value).optional(),
+        lt: value.optional(),
+        lte: value.optional(),
+        gt: value.optional(),
+        gte: value.optional(),
+        contains: zod.string().optional(),
+        startsWith: zod.string().optional(),
+        endsWith: zod.string().optional(),
+        mode: zod.string().optional(),
+      })
+      .partial();
+
+    return zod
+      .preprocess((input) => {
+        // let undefined through
+        if (input === undefined) return input;
+
+        // Already an object (likely { equals, in, ... }) → validate as-is
+        if (typeof input === 'object' && input !== null && !Array.isArray(input)) {
+          return input;
+        }
+
+        // Prisma-style shorthand: profileId: 'abc'  -> { equals: 'abc' }
+        return { equals: input };
+      }, opsSchema)
+      .optional();
+  };
+
+  const fieldFilters = Object.fromEntries(Object.entries(fields).map(([key, value]) => [key, makeFieldFilter(value)]));
+
+  if (depth <= 0) {
+    // Base case: no AND/OR/NOT
+    return zod.object({
+      ...fieldFilters,
+    });
+  }
+
+  return zod.object({
+    AND: zod.array(zod.lazy(() => createPrismaWhereSchema(modelSchema, depth - 1))).optional(),
+    OR: zod.array(zod.lazy(() => createPrismaWhereSchema(modelSchema, depth - 1))).optional(),
+    NOT: zod.array(zod.lazy(() => createPrismaWhereSchema(modelSchema, depth - 1))).optional(),
+    ...fieldFilters,
+  });
+};
+
+export const getQueryOutput = <T extends zod.ZodTypeAny>(data: T) => {
+  return z.object({ status: z.number(), data: data.optional(), error: z.string().optional() });
+};
+
+export const getQueryInput = <S extends zod.ZodTypeAny>(schema: S, options: { partialData?: boolean } = {}) => {
+  const { partialData = true } = options;
+
+  // Only object schemas get "where" support.
+  const isObjectSchema = schema instanceof zod.ZodObject;
+
+  const whereSchema = isObjectSchema
+    ? createPrismaWhereSchema(schema as any) // keep your existing recursive builder
+    : zod.never(); // not used; also prevents people from sending "where" for arrays
+
+  const dataSchema = isObjectSchema
+    ? partialData
+      ? (schema as any).partial().optional()
+      : (schema as any).optional()
+    : schema.optional(); // arrays: allow full array
+
+  const querySchema = zod
+    .object({
+      data: dataSchema,
+
+      // keep your query envelope fields
+      skip: zod.number().default(0).optional(),
+      limit: zod.number().default(10).optional(),
+      cursor: zod.record(zod.any()).optional(),
+
+      // only valid for object schemas
+      where: isObjectSchema ? whereSchema.optional() : zod.undefined().optional(),
+
+      orderBy: zod.record(zod.enum(['asc', 'desc'])).optional(),
+      include: zod.record(zod.boolean()).optional(),
+      select: zod.record(zod.boolean()).optional(),
+    })
+    .partial();
+
+  return zod.union([querySchema, zod.undefined()]);
+};
+
+export type inferQuery<T extends zod.ZodRawShape> = zod.infer<ReturnType<typeof createPrismaWhereSchema<T>>>;
+
+export type GetInferenceHelpers<
+  TType extends 'input' | 'output',
+  TRoot extends AnyTRPCClientTypes,
+  TRecord extends TRPCRouterRecord
+> = {
+  [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value
+    ? $Value extends TRPCRouterRecord
+      ? GetInferenceHelpers<TType, TRoot, $Value>
+      : $Value extends AnyProcedure
+      ? inferProcedureOutput<$Value> // inferTransformedProcedureOutput<TRoot, $Value>
+      : never
+    : never;
+};
+
+export type inferRouterOutputs<TRouter extends AnyRouter> = GetInferenceHelpers<
+  'output',
+  TRouter['_def']['_config']['$types'],
+  TRouter['_def']['record']
+>;
+
+// type SpecificOutput = Router['_def']['record']['createInterfaceDraft']['_def']['$types']['output'];
+// type TestOutput = RouterOutput['createInterfaceDraft'];

package/skill/index.ts

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

package/skill/skill.models.ts

@@ -0,0 +1,16 @@
+import * as mongo from '../../util/mongo';
+import type * as Types from './skill.types';
+
+export const Skill = mongo.createModel<Types.SkillDocument>('Skill', {});
+
+export const SkillMod = mongo.createModel<Types.SkillModDocument>('SkillMod', {});
+
+export const SkillClassification = mongo.createModel<Types.SkillClassificationDocument>('SkillClassification', {});
+
+export const SkillCondition = mongo.createModel<Types.SkillConditionDocument>('SkillCondition', {});
+
+export const SkillStatusEffect = mongo.createModel<Types.SkillStatusEffectDocument>('SkillStatusEffect', {});
+
+export const SkillTree = mongo.createModel<Types.SkillTreeDocument>('SkillTree', {});
+
+export const SkillTreeNode = mongo.createModel<Types.SkillTreeNodeDocument>('SkillTreeNode', {});