@arken/node 1.5.1 → 1.5.3

package/build/modules/core/core.router.js

@@ -1,1372 +0,0 @@
-import { z as zod } from 'zod';
-import { initTRPC } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '../../util/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