@arken/seer-protocol 0.1.4 → 0.1.5

package/build/core/core.router.js

@@ -0,0 +1,1372 @@
+import { z as zod } from 'zod';
+import { initTRPC } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
+import { getQueryInput } from '../schema';
+import { Account, Achievement, Act, Agent, Application, Badge, BattlePass, Biome, BiomeFeature, Bounty, Collection, Comment, Community, Company, Conversation, ConversationMessage, Data, Discussion, Energy, Event, File, Galaxy, Guide, Idea, Leaderboard, Log, Lore, Memory, Message, Metaverse, NewsArticle, Npc, Offer, Omniverse, Order, Payment, Permission, Person, Planet, Poll, Project, Proposal, Quest, Rating, Realm, RealmEvent, RealmShard, Revision, Referral, Review, Role, Season, Session, SolarSystem, Star, Stash, Stock, Suggestion, Tag, Team, Tournament, Trade, Universe, Validator, Vote, WorldEvent, WorldRecord, Stat, } from './core.schema';
+export const z = zod;
+export const t = initTRPC.context().create();
+export const router = t.router;
+export const procedure = t.procedure;
+export const createRouter = () => router({
+    getConversation: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Conversation))
+        .output(Conversation)
+        .query(({ input, ctx }) => ctx.app.service.Core.getConversation(input, ctx)),
+    createConversation: procedure
+        .use(hasRole('user', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Conversation))
+        .output(Conversation.pick({ id: true, name: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createConversation(input, ctx)),
+    updateConversation: procedure
+        .use(hasRole('user', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Conversation))
+        .output(Conversation.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateConversation(input, ctx)),
+    getConversations: procedure
+        .use(hasRole('user', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Conversation))
+        .output(z.object({ items: z.array(Conversation), total: z.number() }))
+        .query(({ input, ctx }) => ctx.app.service.Core.getConversations(input, ctx)),
+    getConversationMessage: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(ConversationMessage))
+        .output(ConversationMessage)
+        .query(({ input, ctx }) => ctx.app.service.Core.getConversationMessage(input, ctx)),
+    getConversationMessages: procedure
+        .use(hasRole('user', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(ConversationMessage))
+        .output(z.object({ items: z.array(ConversationMessage), total: z.number() }))
+        .query(({ input, ctx }) => ctx.app.service.Core.getConversationMessages(input, ctx)),
+    createConversationMessage: procedure
+        .use(hasRole('user', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(ConversationMessage))
+        .output(ConversationMessage)
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createConversationMessage(input, ctx)),
+    updateConversationMessage: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(ConversationMessage))
+        .output(ConversationMessage.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateConversationMessage(input, ctx)),
+    claimConversationMessage: procedure
+        .use(customErrorFormatter(t))
+        .input(z.object({
+        messageId: z.string().min(6),
+        characterId: z.string().optional(),
+    }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.claimConversationMessage(input, ctx)),
+    setConversationMessageStar: procedure
+        .use(customErrorFormatter(t))
+        .input(z.object({
+        messageId: z.string().min(6),
+        isStarred: z.boolean().optional(),
+    }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.setConversationMessageStar(input, ctx)),
+    markConversationRead: procedure
+        .use(hasRole('user', t))
+        .use(customErrorFormatter(t))
+        .input(z
+        .object({
+        messageIds: z.array(z.string().min(6)).optional(),
+        conversationId: z.string().min(6).optional(),
+        limit: z.number().int().min(1).max(200).optional(),
+    })
+        .optional())
+        .mutation(({ input, ctx }) => ctx.app.service.Core.markConversationRead(input, ctx)),
+    archiveReadConversations: procedure
+        .use(hasRole('user', t))
+        .use(customErrorFormatter(t))
+        .input(z
+        .object({
+        conversationId: z.string().min(6),
+    })
+        .optional())
+        .mutation(({ input, ctx }) => ctx.app.service.Core.archiveReadConversations(input, ctx)),
+    readAndClaimLatestMail: procedure
+        .use(hasRole('user', t))
+        .use(customErrorFormatter(t))
+        .input(z
+        .object({
+        conversationId: z.string().min(6),
+        limit: z.number().int().min(1).max(200).optional(),
+        characterId: z.string().min(6).optional(),
+    })
+        .optional())
+        .mutation(({ input, ctx }) => ctx.app.service.Core.readAndClaimLatestMail(input, ctx)),
+    distributeSantaChristmasTicketToProfile: procedure
+        .use(customErrorFormatter(t))
+        .input(z.object({
+        profileId: z.string().min(6),
+        dedupeKey: z.string().optional(),
+    }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.distributeSantaChristmasTicketToProfile(input, ctx)),
+    distributeSantaChristmasTicket: procedure
+        .input(z
+        .object({
+        batchSize: z.number().int().min(100).max(5000).optional(),
+        dedupeKey: z.string().min(3).optional(),
+    })
+        .optional())
+        .query(({ input, ctx }) => ctx.app.service.Core.distributeSantaChristmasTicket(input, ctx)),
+    syncGetPayloadsSince: procedure
+        .input(z.object({
+        since: z.string().datetime(),
+    }))
+        .query(({ input, ctx }) => ctx.app.service.Core.syncGetPayloadsSince(input, ctx)),
+    updateSettings: procedure
+        .use(hasRole('user', t))
+        .use(customErrorFormatter(t))
+        .input(z.any())
+        .query(({ input, ctx }) => ctx.app.service.Core.updateSettings(input, ctx)),
+    ask: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({
+        data: z.object({
+            conversationId: z.string(),
+            messages: z.any(),
+        }),
+    }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.ask(input, ctx)),
+    authorize: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(z.object({
+        address: z.string(),
+        token: z.string().optional(),
+        data: z.string().optional(),
+        loginAs: z.string().optional(),
+    }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.authorize(input, ctx)),
+    getAccount: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Account))
+        .output(Account)
+        .query(({ input, ctx }) => ctx.app.service.Core.getAccount(input, ctx)),
+    getAccounts: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Account))
+        .output(Account.array())
+        .query(({ input, ctx }) => ctx.app.service.Core.getAccounts(input, ctx)),
+    createAccount: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Account))
+        .output(Account.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createAccount(input, ctx)),
+    updateAccount: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Account))
+        .output(Account.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateAccount(input, ctx)),
+    getAchievement: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Achievement))
+        .output(Achievement)
+        .query(({ input, ctx }) => ctx.app.service.Core.getAchievement(input, ctx)),
+    getAchievements: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Achievement))
+        .output(Achievement.array())
+        .query(({ input, ctx }) => ctx.app.service.Core.getAchievements(input, ctx)),
+    createAchievement: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Achievement))
+        .output(Achievement.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createAchievement(input, ctx)),
+    updateAchievement: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Achievement))
+        .output(Achievement.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateAchievement(input, ctx)),
+    getAct: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Act))
+        .output(Act)
+        .query(({ input, ctx }) => ctx.app.service.Core.getAct(input, ctx)),
+    getActs: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Act))
+        .query(({ input, ctx }) => ctx.app.service.Core.getActs(input, ctx)),
+    createAct: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Act))
+        .output(Act.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createAct(input, ctx)),
+    updateAct: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Act))
+        .output(Act.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateAct(input, ctx)),
+    getAgent: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Agent))
+        .output(Agent)
+        .query(({ input, ctx }) => ctx.app.service.Core.getAgent(input, ctx)),
+    createAgent: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Agent))
+        .output(Agent.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createAgent(input, ctx)),
+    updateAgent: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Agent))
+        .output(Agent.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateAgent(input, ctx)),
+    getApplication: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Application))
+        .output(Application)
+        .query(({ input, ctx }) => ctx.app.service.Core.getApplication(input, ctx)),
+    createApplication: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Application))
+        .output(Application.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createApplication(input, ctx)),
+    updateApplication: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Application))
+        .output(Application.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateApplication(input, ctx)),
+    getBadge: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Badge))
+        .output(Badge)
+        .query(({ input, ctx }) => ctx.app.service.Core.getBadge(input, ctx)),
+    createBadge: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Badge))
+        .output(Badge.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createBadge(input, ctx)),
+    updateBadge: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Badge))
+        .output(Badge.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateBadge(input, ctx)),
+    getBattlePass: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(BattlePass))
+        .output(BattlePass)
+        .query(({ input, ctx }) => ctx.app.service.Core.getBattlePass(input, ctx)),
+    createBattlePass: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(BattlePass))
+        .output(BattlePass.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createBattlePass(input, ctx)),
+    updateBattlePass: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(BattlePass))
+        .output(BattlePass.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateBattlePass(input, ctx)),
+    getBiome: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Biome))
+        .output(Biome)
+        .query(({ input, ctx }) => ctx.app.service.Core.getBiome(input, ctx)),
+    createBiome: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Biome))
+        .output(Biome.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createBiome(input, ctx)),
+    updateBiome: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Biome))
+        .output(Biome.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateBiome(input, ctx)),
+    getBiomeFeature: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(BiomeFeature))
+        .output(BiomeFeature)
+        .query(({ input, ctx }) => ctx.app.service.Core.getBiomeFeature(input, ctx)),
+    createBiomeFeature: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(BiomeFeature)
+        .output(BiomeFeature.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createBiomeFeature(input, ctx)),
+    updateBiomeFeature: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(BiomeFeature))
+        .output(BiomeFeature.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateBiomeFeature(input, ctx)),
+    getBounty: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Bounty))
+        .output(Bounty)
+        .query(({ input, ctx }) => ctx.app.service.Core.getBounty(input, ctx)),
+    createBounty: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Bounty))
+        .output(Bounty.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createBounty(input, ctx)),
+    updateBounty: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Bounty))
+        .output(Bounty.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateBounty(input, ctx)),
+    getCollection: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Collection))
+        .output(Collection)
+        .query(({ input, ctx }) => ctx.app.service.Core.getCollection(input, ctx)),
+    createCollection: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Collection))
+        .output(Collection.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createCollection(input, ctx)),
+    updateCollection: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Collection))
+        .output(Collection.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateCollection(input, ctx)),
+    getComment: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Comment))
+        .output(Comment)
+        .query(({ input, ctx }) => ctx.app.service.Core.getComment(input, ctx)),
+    createComment: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Comment))
+        .output(Comment.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createComment(input, ctx)),
+    updateComment: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Comment))
+        .output(Comment.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateComment(input, ctx)),
+    getCommunity: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Community))
+        .output(Community)
+        .query(({ input, ctx }) => ctx.app.service.Core.getCommunity(input, ctx)),
+    createCommunity: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Community))
+        .output(Community.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createCommunity(input, ctx)),
+    updateCommunity: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Community))
+        .output(Community.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateCommunity(input, ctx)),
+    getCompany: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Company))
+        .output(Company)
+        .query(({ input, ctx }) => ctx.app.service.Core.getCompany(input, ctx)),
+    createCompany: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Company))
+        .output(Company.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createCompany(input, ctx)),
+    updateCompany: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Company))
+        .output(Company.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateCompany(input, ctx)),
+    getData: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Data))
+        .output(Data)
+        .query(({ input, ctx }) => ctx.app.service.Core.getData(input, ctx)),
+    createData: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Data))
+        .output(Data.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createData(input, ctx)),
+    updateData: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Data))
+        .output(Data.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateData(input, ctx)),
+    getDiscussion: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Discussion))
+        .output(Discussion)
+        .query(({ input, ctx }) => ctx.app.service.Core.getDiscussion(input, ctx)),
+    createDiscussion: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Discussion))
+        .output(Discussion.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createDiscussion(input, ctx)),
+    updateDiscussion: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Discussion))
+        .output(Discussion.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateDiscussion(input, ctx)),
+    getEnergy: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Energy))
+        .output(Energy)
+        .query(({ input, ctx }) => ctx.app.service.Core.getEnergy(input, ctx)),
+    getEnergies: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Energy))
+        .query(({ input, ctx }) => ctx.app.service.Core.getEnergies(input, ctx)),
+    createEnergy: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Energy))
+        .output(Energy.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createEnergy(input, ctx)),
+    updateEnergy: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Energy))
+        .output(Energy.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateEnergy(input, ctx)),
+    getEvent: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Event))
+        .output(Event)
+        .query(({ input, ctx }) => ctx.app.service.Core.getEvent(input, ctx)),
+    createEvent: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Event))
+        .output(Event.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createEvent(input, ctx)),
+    updateEvent: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Event))
+        .output(Event.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateEvent(input, ctx)),
+    getFile: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(File))
+        .output(File)
+        .query(({ input, ctx }) => ctx.app.service.Core.getFile(input, ctx)),
+    createFile: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(File))
+        .output(File.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createFile(input, ctx)),
+    updateFile: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(File))
+        .output(File.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateFile(input, ctx)),
+    getGalaxy: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Galaxy))
+        .output(Galaxy)
+        .query(({ input, ctx }) => ctx.app.service.Core.getGalaxy(input, ctx)),
+    createGalaxy: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Galaxy))
+        .output(Galaxy.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createGalaxy(input, ctx)),
+    updateGalaxy: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Galaxy))
+        .output(Galaxy.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateGalaxy(input, ctx)),
+    getGuide: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Guide))
+        .output(Guide)
+        .query(({ input, ctx }) => ctx.app.service.Core.getGuide(input, ctx)),
+    createGuide: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Guide))
+        .output(Guide.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createGuide(input, ctx)),
+    updateGuide: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Guide))
+        .output(Guide.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateGuide(input, ctx)),
+    getIdea: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Idea))
+        .output(Idea)
+        .query(({ input, ctx }) => ctx.app.service.Core.getIdea(input, ctx)),
+    createIdea: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Idea))
+        .output(Idea.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createIdea(input, ctx)),
+    updateIdea: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Idea))
+        .output(Idea.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateIdea(input, ctx)),
+    getLeaderboard: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Leaderboard))
+        .output(Leaderboard)
+        .query(({ input, ctx }) => ctx.app.service.Core.getLeaderboard(input, ctx)),
+    createLeaderboard: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Leaderboard))
+        .output(Leaderboard.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createLeaderboard(input, ctx)),
+    updateLeaderboard: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Leaderboard))
+        .output(Leaderboard.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateLeaderboard(input, ctx)),
+    getLog: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Log))
+        .output(Log)
+        .query(({ input, ctx }) => ctx.app.service.Core.getLog(input, ctx)),
+    createLog: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Log))
+        .output(Log.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createLog(input, ctx)),
+    updateLog: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Log))
+        .output(Log.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateLog(input, ctx)),
+    getLore: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Lore))
+        .output(Lore)
+        .query(({ input, ctx }) => ctx.app.service.Core.getLore(input, ctx)),
+    createLore: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Lore))
+        .output(Lore.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createLore(input, ctx)),
+    updateLore: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Lore))
+        .output(Lore.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateLore(input, ctx)),
+    getMemory: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Memory))
+        .output(Memory)
+        .query(({ input, ctx }) => ctx.app.service.Core.getMemory(input, ctx)),
+    createMemory: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Memory))
+        .output(Memory.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createMemory(input, ctx)),
+    updateMemory: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Memory))
+        .output(Memory.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateMemory(input, ctx)),
+    getMessage: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Message))
+        .output(Message)
+        .query(({ input, ctx }) => ctx.app.service.Core.getMessage(input, ctx)),
+    createMessage: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Message))
+        .output(Message.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createMessage(input, ctx)),
+    updateMessage: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Message))
+        .output(Message.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateMessage(input, ctx)),
+    getMetaverse: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Metaverse))
+        .output(Metaverse)
+        .query(({ input, ctx }) => ctx.app.service.Core.getMetaverse(input, ctx)),
+    createMetaverse: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Metaverse))
+        .output(Metaverse.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createMetaverse(input, ctx)),
+    updateMetaverse: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Metaverse))
+        .output(Metaverse.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateMetaverse(input, ctx)),
+    getNewsArticle: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(NewsArticle))
+        .output(NewsArticle)
+        .query(({ input, ctx }) => ctx.app.service.Core.getNewsArticle(input, ctx)),
+    createNewsArticle: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(NewsArticle))
+        .output(NewsArticle.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createNewsArticle(input, ctx)),
+    updateNewsArticle: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(NewsArticle))
+        .output(NewsArticle.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateNewsArticle(input, ctx)),
+    getNpc: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Npc))
+        .output(Npc)
+        .query(({ input, ctx }) => ctx.app.service.Core.getNpc(input, ctx)),
+    createNpc: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Npc))
+        .output(Npc.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createNpc(input, ctx)),
+    updateNpc: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Npc))
+        .output(Npc.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateNpc(input, ctx)),
+    getOffer: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Offer))
+        .output(Offer)
+        .query(({ input, ctx }) => ctx.app.service.Core.getOffer(input, ctx)),
+    createOffer: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Offer))
+        .output(Offer.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createOffer(input, ctx)),
+    updateOffer: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Offer))
+        .output(Offer.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateOffer(input, ctx)),
+    getOmniverse: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Omniverse))
+        .output(Omniverse)
+        .query(({ input, ctx }) => ctx.app.service.Core.getOmniverse(input, ctx)),
+    createOmniverse: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Omniverse))
+        .output(Omniverse.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createOmniverse(input, ctx)),
+    updateOmniverse: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Omniverse))
+        .output(Omniverse.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateOmniverse(input, ctx)),
+    getOrder: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Order))
+        .output(Order)
+        .query(({ input, ctx }) => ctx.app.service.Core.getOrder(input, ctx)),
+    createOrder: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Order))
+        .output(Order.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createOrder(input, ctx)),
+    updateOrder: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Order))
+        .output(Order.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateOrder(input, ctx)),
+    getPayment: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Payment))
+        .output(Payment)
+        .query(({ input, ctx }) => ctx.app.service.Core.getPayment(input, ctx)),
+    createPayment: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Payment))
+        .output(Payment.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createPayment(input, ctx)),
+    updatePayment: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Payment))
+        .output(Payment.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updatePayment(input, ctx)),
+    getPermission: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Permission))
+        .output(Permission)
+        .query(({ input, ctx }) => ctx.app.service.Core.getPermission(input, ctx)),
+    createPermission: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Permission))
+        .output(Permission.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createPermission(input, ctx)),
+    updatePermission: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Permission))
+        .output(Permission.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updatePermission(input, ctx)),
+    getPerson: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Person))
+        .output(Person)
+        .query(({ input, ctx }) => ctx.app.service.Core.getPerson(input, ctx)),
+    createPerson: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Person))
+        .output(Person.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createPerson(input, ctx)),
+    updatePerson: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Person))
+        .output(Person.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updatePerson(input, ctx)),
+    getPlanet: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Planet))
+        .output(Planet)
+        .query(({ input, ctx }) => ctx.app.service.Core.getPlanet(input, ctx)),
+    createPlanet: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Planet))
+        .output(Planet.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createPlanet(input, ctx)),
+    updatePlanet: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Planet))
+        .output(Planet.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updatePlanet(input, ctx)),
+    getPoll: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Poll))
+        .output(Poll)
+        .query(({ input, ctx }) => ctx.app.service.Core.getPoll(input, ctx)),
+    createPoll: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Poll))
+        .output(Poll.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createPoll(input, ctx)),
+    updatePoll: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Poll))
+        .output(Poll.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updatePoll(input, ctx)),
+    getProject: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Project))
+        .output(Project)
+        .query(({ input, ctx }) => ctx.app.service.Core.getProject(input, ctx)),
+    createProject: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Project))
+        .output(Project.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createProject(input, ctx)),
+    updateProject: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Project))
+        .output(Project.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateProject(input, ctx)),
+    getProposal: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Proposal))
+        .output(Proposal)
+        .query(({ input, ctx }) => ctx.app.service.Core.getProposal(input, ctx)),
+    createProposal: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Proposal))
+        .output(Proposal.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createProposal(input, ctx)),
+    updateProposal: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Proposal))
+        .output(Proposal.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateProposal(input, ctx)),
+    getQuest: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Quest))
+        .output(Quest)
+        .query(({ input, ctx }) => ctx.app.service.Core.getQuest(input, ctx)),
+    createQuest: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Quest))
+        .output(Quest.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createQuest(input, ctx)),
+    updateQuest: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Quest))
+        .output(Quest.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateQuest(input, ctx)),
+    getRating: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Rating))
+        .output(Rating)
+        .query(({ input, ctx }) => ctx.app.service.Core.getRating(input, ctx)),
+    createRating: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Rating))
+        .output(Rating.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createRating(input, ctx)),
+    updateRating: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Rating))
+        .output(Rating.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateRating(input, ctx)),
+    getRealm: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Realm))
+        .output(Realm)
+        .query(({ input, ctx }) => ctx.app.service.Core.getRealm(input, ctx)),
+    getRealms: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Realm))
+        .output(z.array(Realm))
+        .query(({ input, ctx }) => ctx.app.service.Core.getRealms(input, ctx)),
+    createRealm: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Realm))
+        .output(Realm.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createRealm(input, ctx)),
+    updateRealm: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Realm))
+        .output(Realm.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateRealm(input, ctx)),
+    getRealmEvent: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(RealmEvent))
+        .output(RealmEvent)
+        .query(({ input, ctx }) => ctx.app.service.Core.getRealmEvent(input, ctx)),
+    getRealmEvents: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(RealmEvent))
+        .output(z.array(RealmEvent))
+        .query(({ input, ctx }) => ctx.app.service.Core.getRealmEvents(input, ctx)),
+    createRealmEvent: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(RealmEvent))
+        .output(RealmEvent.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createRealmEvent(input, ctx)),
+    updateRealmEvent: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(RealmEvent))
+        .output(RealmEvent.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateRealmEvent(input, ctx)),
+    getRevision: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Revision))
+        .output(Revision)
+        .query(({ input, ctx }) => ctx.app.service.Core.getRevision(input, ctx)),
+    createRevision: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Revision))
+        .output(Revision.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createRevision(input, ctx)),
+    updateRevision: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Revision))
+        .output(Revision.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateRevision(input, ctx)),
+    getReferral: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Referral))
+        .output(Referral)
+        .query(({ input, ctx }) => ctx.app.service.Core.getReferral(input, ctx)),
+    createReferral: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Referral))
+        .output(Referral.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createReferral(input, ctx)),
+    updateReferral: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Referral))
+        .output(Referral.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateReferral(input, ctx)),
+    getReview: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Review))
+        .output(Review)
+        .query(({ input, ctx }) => ctx.app.service.Core.getReview(input, ctx)),
+    createReview: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Review))
+        .output(Review.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createReview(input, ctx)),
+    updateReview: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Review))
+        .output(Review.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateReview(input, ctx)),
+    getRole: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Role))
+        .output(Role)
+        .query(({ input, ctx }) => ctx.app.service.Core.getRole(input, ctx)),
+    createRole: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Role))
+        .output(Role.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createRole(input, ctx)),
+    updateRole: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Role))
+        .output(Role.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateRole(input, ctx)),
+    getSeason: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Season))
+        .output(Season)
+        .query(({ input, ctx }) => ctx.app.service.Core.getSeason(input, ctx)),
+    createSeason: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Season))
+        .output(Season.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createSeason(input, ctx)),
+    updateSeason: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Season))
+        .output(Season.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateSeason(input, ctx)),
+    getRealmShard: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(RealmShard))
+        .output(RealmShard)
+        .query(({ input, ctx }) => ctx.app.service.Core.getRealmShard(input, ctx)),
+    getRealmShards: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(RealmShard))
+        .output(z.array(RealmShard))
+        .query(({ input, ctx }) => ctx.app.service.Core.getRealmShards(input, ctx)),
+    createRealmShard: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(RealmShard))
+        .output(RealmShard.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createRealmShard(input, ctx)),
+    updateRealmShard: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(RealmShard))
+        .output(RealmShard.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateRealmShard(input, ctx)),
+    getSession: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Session))
+        .output(Session)
+        .query(({ input, ctx }) => ctx.app.service.Core.getSession(input, ctx)),
+    createSession: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Session))
+        .output(Session.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createSession(input, ctx)),
+    updateSession: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Session))
+        .output(Session.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateSession(input, ctx)),
+    getSolarSystem: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(SolarSystem))
+        .output(SolarSystem)
+        .query(({ input, ctx }) => ctx.app.service.Core.getSolarSystem(input, ctx)),
+    createSolarSystem: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(SolarSystem))
+        .output(SolarSystem.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createSolarSystem(input, ctx)),
+    updateSolarSystem: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(SolarSystem))
+        .output(SolarSystem.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateSolarSystem(input, ctx)),
+    getStar: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Star))
+        .output(Star)
+        .query(({ input, ctx }) => ctx.app.service.Core.getStar(input, ctx)),
+    createStar: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Star))
+        .output(Star.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createStar(input, ctx)),
+    updateStar: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Star))
+        .output(Star.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateStar(input, ctx)),
+    getStash: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Stash))
+        .output(Stash)
+        .query(({ input, ctx }) => ctx.app.service.Core.getStash(input, ctx)),
+    createStash: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Stash))
+        .output(Stash.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createStash(input, ctx)),
+    updateStash: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Stash))
+        .output(Stash.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateStash(input, ctx)),
+    getStock: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Stock))
+        .output(Stock)
+        .query(({ input, ctx }) => ctx.app.service.Core.getStock(input, ctx)),
+    createStock: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Stock))
+        .output(Stock.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createStock(input, ctx)),
+    updateStock: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Stock))
+        .output(Stock.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateStock(input, ctx)),
+    getSuggestion: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Suggestion))
+        .output(Suggestion)
+        .query(({ input, ctx }) => ctx.app.service.Core.getSuggestion(input, ctx)),
+    createSuggestion: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Suggestion))
+        .output(Suggestion.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createSuggestion(input, ctx)),
+    updateSuggestion: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Suggestion))
+        .output(Suggestion.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateSuggestion(input, ctx)),
+    getTag: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Tag))
+        .output(Tag)
+        .query(({ input, ctx }) => ctx.app.service.Core.getTag(input, ctx)),
+    createTag: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Tag))
+        .output(Tag.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createTag(input, ctx)),
+    updateTag: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Tag))
+        .output(Tag.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateTag(input, ctx)),
+    getTeam: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Team))
+        .output(Team)
+        .query(({ input, ctx }) => ctx.app.service.Core.getTeam(input, ctx)),
+    getTeams: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Team))
+        .output(z.array(Team))
+        .query(({ input, ctx }) => ctx.app.service.Core.getTeams(input, ctx)),
+    createTeam: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Team))
+        .output(Team.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createTeam(input, ctx)),
+    updateTeam: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Team))
+        .output(Team.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateTeam(input, ctx)),
+    getTournament: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Tournament))
+        .output(Tournament)
+        .query(({ input, ctx }) => ctx.app.service.Core.getTournament(input, ctx)),
+    createTournament: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Tournament))
+        .output(Tournament.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createTournament(input, ctx)),
+    updateTournament: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Tournament))
+        .output(Tournament.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateTournament(input, ctx)),
+    getTrade: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Trade))
+        .output(Trade)
+        .query(({ input, ctx }) => ctx.app.service.Core.getTrade(input, ctx)),
+    getTrades: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Trade))
+        .output(z.array(Trade))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.getTrades(input, ctx)),
+    createTrade: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Trade))
+        .output(Trade.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createTrade(input, ctx)),
+    updateTrade: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Trade))
+        .output(Trade.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateTrade(input, ctx)),
+    getUniverse: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Universe))
+        .output(Universe)
+        .query(({ input, ctx }) => ctx.app.service.Core.getUniverse(input, ctx)),
+    createUniverse: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Universe))
+        .output(Universe.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createUniverse(input, ctx)),
+    updateUniverse: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Universe))
+        .output(Universe.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateUniverse(input, ctx)),
+    getValidator: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Validator))
+        .output(Validator)
+        .query(({ input, ctx }) => ctx.app.service.Core.getValidator(input, ctx)),
+    createValidator: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Validator))
+        .output(Validator.pick({ id: true }))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createValidator(input, ctx)),
+    updateValidator: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Validator))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateValidator(input, ctx)),
+    getVote: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Vote))
+        .query(({ input, ctx }) => ctx.app.service.Core.getVote(input, ctx)),
+    createVote: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Vote))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createVote(input, ctx)),
+    updateVote: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Vote))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateVote(input, ctx)),
+    getWorldEvent: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(WorldEvent))
+        .query(({ input, ctx }) => ctx.app.service.Core.getWorldEvent(input, ctx)),
+    createWorldEvent: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(WorldEvent))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createWorldEvent(input, ctx)),
+    updateWorldEvent: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(WorldEvent))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateWorldEvent(input, ctx)),
+    getWorldRecord: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(WorldRecord))
+        .query(({ input, ctx }) => ctx.app.service.Core.getWorldRecord(input, ctx)),
+    createWorldRecord: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(WorldRecord))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.createWorldRecord(input, ctx)),
+    updateWorldRecord: procedure
+        .use(hasRole('admin', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(WorldRecord))
+        .mutation(({ input, ctx }) => ctx.app.service.Core.updateWorldRecord(input, ctx)),
+    info: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(z.any())
+        .query(({ input, ctx }) => ctx.app.service.Core.info(input, ctx)),
+    stats: procedure
+        .use(hasRole('guest', t))
+        .use(customErrorFormatter(t))
+        .input(getQueryInput(Stat))
+        .query(({ input, ctx }) => ctx.app.service.Core.stats(input, ctx)),
+});
+//# sourceMappingURL=core.router.js.map