@gbl-uzh/platform 0.2.10

package/dist/index.d.ts

@@ -0,0 +1,430 @@
+import * as _prisma_client from '.prisma/client';
+import { PrismaClient } from '@prisma/client';
+import { NextPageContext } from 'next';
+import * as yup from 'yup';
+import yup__default from 'yup';
+import { PlayerDecisionType } from './generated/ops.js';
+import 'graphql';
+import '@graphql-typed-document-node/core';
+
+declare enum UserRole {
+    PLAYER = "PLAYER",
+    ADMIN = "ADMIN"
+}
+declare enum LearningElementState {
+    NEW = "NEW",
+    ATTEMPTED = "ATTEMPTED",
+    SOLVED = "SOLVED"
+}
+declare type Notification<NotificationType> = {
+    type: NotificationType;
+    sub?: string;
+    facts?: any;
+};
+declare type Event<EventType> = {
+    type: EventType;
+    sub?: string;
+    facts?: any;
+};
+declare type Output<OutputType, NotificationType, EventType> = {
+    type: OutputType;
+    extras?: any;
+    result: any;
+    notifications: Notification<NotificationType>[];
+    events: Event<EventType>[];
+    actions?: any[];
+    isDirty: boolean;
+};
+declare type Action<ActionType, PayloadType, PrismaType> = {
+    type: ActionType;
+    payload: PayloadType;
+    ctx?: CtxWithPrisma<PrismaType>;
+};
+interface Reducer<StateType, ActionType, PayloadType, OutputType, NotificationType, EventType, PrismaType> {
+    apply: (state: StateType, action: Action<ActionType, PayloadType, PrismaType>) => Output<OutputType, NotificationType, EventType>;
+    ActionTypes: Record<string, string>;
+}
+interface Reducers<PrismaType> {
+    Actions: Reducer<any, any, any, any, any, any, PrismaType>;
+    Period: Reducer<any, any, any, any, any, any, PrismaType>;
+    PeriodResult: Reducer<any, any, any, any, any, any, PrismaType>;
+    Segment: Reducer<any, any, any, any, any, any, PrismaType>;
+    SegmentResult: Reducer<any, any, any, any, any, any, PrismaType>;
+    [key: string]: Reducer<any, any, any, any, any, any, PrismaType>;
+}
+interface CtxWithPrisma<PrismaType> extends NextPageContext {
+    prisma: PrismaType;
+    user: {
+        sub: string;
+        role: UserRole;
+        gameId?: number;
+    };
+}
+interface CtxWithFacts<FactsType, PrismaType> {
+    reducers: Reducers<PrismaType>;
+}
+interface CtxWithFactsAndSchema<FactsType, PrismaType> {
+    schema: yup__default.Schema<FactsType>;
+    reducers: Reducers<PrismaType>;
+}
+declare enum BaseGlobalNotificationType {
+    PERIOD_ACTIVATED = "PERIOD_ACTIVATED",
+    SEGMENT_ACTIVATED = "SEGMENT_ACTIVATED"
+}
+declare enum BaseUserNotificationType {
+    LEARNING_ELEMENT_SOLVED = "LEARNING_ELEMENT_SOLVED",
+    LEARNING_ELEMENT_INCORRECT = "LEARNING_ELEMENT_INCORRECT",
+    ACHIEVEMENT_RECEIVED = "ACHIEVEMENT_RECEIVED",
+    LEVEL_UP = "LEVEL_UP"
+}
+
+interface CreateLoginTokenArgs {
+    sub: string;
+    role: UserRole;
+    token?: string;
+    gameId?: number;
+}
+declare function createLoginToken({ sub, role, ...extra }: CreateLoginTokenArgs): string;
+interface LoginAsTeamArgs {
+    token: string;
+}
+declare function loginAsTeam({ token }: LoginAsTeamArgs, ctx: CtxWithPrisma<PrismaClient>): Promise<(_prisma_client.Player & {
+    level: _prisma_client.PlayerLevel;
+    achievements: (_prisma_client.AchievementInstance & {
+        achievement: _prisma_client.Achievement;
+    })[];
+}) | null>;
+
+declare const AccountService_createLoginToken: typeof createLoginToken;
+declare const AccountService_loginAsTeam: typeof loginAsTeam;
+declare namespace AccountService {
+  export {
+    AccountService_createLoginToken as createLoginToken,
+    AccountService_loginAsTeam as loginAsTeam,
+  };
+}
+
+declare function receiveEvents({ events, ctx, prisma }: {
+    events: any;
+    ctx: any;
+    prisma: any;
+}): Promise<any>;
+declare function receiveEvent(event: any, definedEvents: any, definedLevels: any, prisma: any): Promise<any[]>;
+declare function publishGlobalNotification(event: any): void;
+declare function publishUserNotification(ctx: {
+    user: {
+        sub: string;
+    };
+}, events?: any): void;
+
+declare const EventService_receiveEvents: typeof receiveEvents;
+declare const EventService_receiveEvent: typeof receiveEvent;
+declare const EventService_publishGlobalNotification: typeof publishGlobalNotification;
+declare const EventService_publishUserNotification: typeof publishUserNotification;
+declare namespace EventService {
+  export {
+    EventService_receiveEvents as receiveEvents,
+    EventService_receiveEvent as receiveEvent,
+    EventService_publishGlobalNotification as publishGlobalNotification,
+    EventService_publishUserNotification as publishUserNotification,
+  };
+}
+
+declare type Context$1 = CtxWithPrisma<PrismaClient>;
+interface CreateGameArgs {
+    name: string;
+    playerCount: number;
+}
+declare function createGame({ name, playerCount }: CreateGameArgs, ctx: Context$1, { roleAssigner }: {
+    roleAssigner: (ix: number) => any;
+}): Promise<_prisma_client.Game & {
+    periods: _prisma_client.Period[];
+    players: _prisma_client.Player[];
+}>;
+interface AddGamePeriodArgs<T> {
+    gameId: number;
+    facts: T;
+}
+declare function addGamePeriod<TFacts>({ gameId, facts }: AddGamePeriodArgs<TFacts>, ctx: Context$1, { schema, reducers }: CtxWithFactsAndSchema<TFacts, PrismaClient>): Promise<(_prisma_client.Period & {
+    segments: (_prisma_client.PeriodSegment & {
+        storyElements: _prisma_client.StoryElement[];
+        learningElements: _prisma_client.LearningElement[];
+    })[];
+}) | null>;
+interface AddPeriodSegmentArgs<TFacts> {
+    gameId: number;
+    periodIx: number;
+    facts: TFacts;
+    learningElements?: string[];
+    storyElements?: string[];
+}
+declare function addPeriodSegment<TFacts>({ gameId, periodIx, facts, learningElements, storyElements, }: AddPeriodSegmentArgs<TFacts>, ctx: Context$1, { schema, reducers }: CtxWithFactsAndSchema<TFacts, PrismaClient>): Promise<(_prisma_client.PeriodSegment & {
+    storyElements: _prisma_client.StoryElement[];
+    learningElements: _prisma_client.LearningElement[];
+}) | null>;
+interface ActivateNextPeriodArgs {
+    gameId: number;
+}
+declare function activateNextPeriod({ gameId }: ActivateNextPeriodArgs, ctx: Context$1, { reducers }: CtxWithFacts<any, PrismaClient>): Promise<[_prisma_client.Game, _prisma_client.Period, ...any[]] | null>;
+interface ActivateSegmentArgs {
+    gameId: number;
+}
+declare function activateNextSegment({ gameId }: ActivateSegmentArgs, ctx: Context$1, { reducers }: CtxWithFacts<any, PrismaClient>): Promise<[_prisma_client.Game, _prisma_client.Period, _prisma_client.PeriodSegment, ...any[]] | [_prisma_client.Game, _prisma_client.PeriodSegment & {
+    results: _prisma_client.PlayerResult[];
+}, ...any[]] | null>;
+declare const PlayerFactsSchema: yup.ObjectSchema<{
+    location: string;
+}, yup.AnyObject, {
+    location: "Zurich";
+}, "">;
+interface PlayerFacts extends yup.InferType<typeof PlayerFactsSchema> {
+}
+interface UpdatePlayerDataArgs {
+    name?: string;
+    avatar?: string;
+    color?: string;
+    facts: PlayerFacts;
+}
+declare function updatePlayerData({ name, avatar, color, facts }: UpdatePlayerDataArgs, ctx: Context$1): Promise<(_prisma_client.Player & {
+    level: _prisma_client.PlayerLevel;
+    achievements: (_prisma_client.AchievementInstance & {
+        achievement: _prisma_client.Achievement;
+    })[];
+}) | null>;
+declare function getGames(args: any, ctx: Context$1): Promise<_prisma_client.Game[]>;
+declare function getGame(args: any, ctx: Context$1): Promise<(_prisma_client.Game & {
+    periods: (_prisma_client.Period & {
+        segments: (_prisma_client.PeriodSegment & {
+            storyElements: _prisma_client.StoryElement[];
+            learningElements: _prisma_client.LearningElement[];
+        })[];
+    })[];
+    players: (_prisma_client.Player & {
+        level: _prisma_client.PlayerLevel;
+        achievements: _prisma_client.AchievementInstance[];
+    })[];
+    activePeriod: (_prisma_client.Period & {
+        segments: _prisma_client.PeriodSegment[];
+        activeSegment: _prisma_client.PeriodSegment | null;
+    }) | null;
+}) | null>;
+declare function getGameFromContext(ctx: Context$1): Promise<(_prisma_client.Game & {
+    activePeriod: _prisma_client.Period | null;
+}) | null>;
+declare function getLearningElements(args: any, ctx: Context$1): Promise<(_prisma_client.LearningElement & {
+    options: _prisma_client.LearningAnswerOption[];
+})[]>;
+declare function computePeriodStartResults({ results, players, activePeriodIx, gameId, periodFacts }: {
+    results: any;
+    players: any;
+    activePeriodIx: any;
+    gameId: any;
+    periodFacts: any;
+}, ctx: any, { reducers }: {
+    reducers: any;
+}): {
+    results: any;
+    extras: any[];
+};
+declare function computePeriodEndResults({ segmentResults, periodFacts, periodDecisions, segmentFacts, activePeriodIx, gameId, }: {
+    segmentResults: any;
+    periodFacts: any;
+    periodDecisions: any;
+    segmentFacts: any;
+    activePeriodIx: any;
+    gameId: any;
+}, ctx: Context$1, { reducers }: {
+    reducers: any;
+}): Promise<{
+    extras: any[];
+    results: any;
+    promises: Promise<any>[];
+}>;
+declare function computeSegmentStartResults(game: any, ctx: any, { reducers }: {
+    reducers: any;
+}): {
+    results: any;
+    extras: any[];
+};
+declare function computeSegmentEndResults(game: any, ctx: any, { reducers }: {
+    reducers: any;
+}): {
+    results: any;
+    extras: any[];
+};
+
+declare const GameService_createGame: typeof createGame;
+declare const GameService_addGamePeriod: typeof addGamePeriod;
+declare const GameService_addPeriodSegment: typeof addPeriodSegment;
+declare const GameService_activateNextPeriod: typeof activateNextPeriod;
+declare const GameService_activateNextSegment: typeof activateNextSegment;
+type GameService_PlayerFacts = PlayerFacts;
+declare const GameService_updatePlayerData: typeof updatePlayerData;
+declare const GameService_getGames: typeof getGames;
+declare const GameService_getGame: typeof getGame;
+declare const GameService_getGameFromContext: typeof getGameFromContext;
+declare const GameService_getLearningElements: typeof getLearningElements;
+declare const GameService_computePeriodStartResults: typeof computePeriodStartResults;
+declare const GameService_computePeriodEndResults: typeof computePeriodEndResults;
+declare const GameService_computeSegmentStartResults: typeof computeSegmentStartResults;
+declare const GameService_computeSegmentEndResults: typeof computeSegmentEndResults;
+declare namespace GameService {
+  export {
+    GameService_createGame as createGame,
+    GameService_addGamePeriod as addGamePeriod,
+    GameService_addPeriodSegment as addPeriodSegment,
+    GameService_activateNextPeriod as activateNextPeriod,
+    GameService_activateNextSegment as activateNextSegment,
+    GameService_PlayerFacts as PlayerFacts,
+    GameService_updatePlayerData as updatePlayerData,
+    GameService_getGames as getGames,
+    GameService_getGame as getGame,
+    GameService_getGameFromContext as getGameFromContext,
+    GameService_getLearningElements as getLearningElements,
+    GameService_computePeriodStartResults as computePeriodStartResults,
+    GameService_computePeriodEndResults as computePeriodEndResults,
+    GameService_computeSegmentStartResults as computeSegmentStartResults,
+    GameService_computeSegmentEndResults as computeSegmentEndResults,
+  };
+}
+
+declare type Context = CtxWithPrisma<PrismaClient>;
+interface PerformActionArgs<ActionTypes> {
+    gameId: number;
+    periodIx: number;
+    segmentIx: number;
+    playerId: string;
+    actionType: ActionTypes;
+    facts: any;
+}
+declare function performAction<ActionTypes>(args: PerformActionArgs<ActionTypes>, ctx: Context, { reducers }: any): Promise<(_prisma_client.PlayerResult & {
+    period: _prisma_client.Period;
+}) | null>;
+interface SaveDecisionsArgs {
+    decisionType: PlayerDecisionType;
+    facts: any;
+}
+declare function saveDecisions(args: SaveDecisionsArgs, ctx: Context): Promise<_prisma_client.PlayerDecision | null>;
+interface GetPlayerResultArgs {
+    gameId: number;
+    playerId: string;
+}
+declare function getPlayerResult(args: GetPlayerResultArgs, ctx: Context): Promise<{
+    currentGame: _prisma_client.Game & {
+        periods: (_prisma_client.Period & {
+            segments: (_prisma_client.PeriodSegment & {
+                storyElements: _prisma_client.StoryElement[];
+                learningElements: _prisma_client.LearningElement[];
+            })[];
+        })[];
+        activePeriod: (_prisma_client.Period & {
+            segments: (_prisma_client.PeriodSegment & {
+                storyElements: _prisma_client.StoryElement[];
+                learningElements: _prisma_client.LearningElement[];
+            })[];
+            activeSegment: (_prisma_client.PeriodSegment & {
+                storyElements: _prisma_client.StoryElement[];
+                learningElements: _prisma_client.LearningElement[];
+            }) | null;
+        }) | null;
+    };
+    playerResult: (_prisma_client.PlayerResult & {
+        period: _prisma_client.Period;
+        player: _prisma_client.Player & {
+            completedLearningElements: _prisma_client.LearningElement[];
+            visitedStoryElements: _prisma_client.StoryElement[];
+        };
+    }) | null;
+    previousResults: _prisma_client.PrismaPromise<(_prisma_client.PlayerResult & {
+        period: _prisma_client.Period;
+    })[]>;
+    transactions: _prisma_client.PrismaPromise<_prisma_client.PlayerAction[]>;
+} | null>;
+interface GetPlayerDataArgs {
+    playerId: string;
+}
+declare function getPlayerData(args: GetPlayerDataArgs, ctx: Context): Promise<(_prisma_client.Player & {
+    level: _prisma_client.PlayerLevel;
+    achievements: (_prisma_client.AchievementInstance & {
+        achievement: _prisma_client.Achievement;
+    })[];
+}) | null>;
+interface GetLearningElementArgs {
+    id: string;
+}
+declare function getLearningElement(args: GetLearningElementArgs, ctx: Context): Promise<{
+    id: string;
+    element: {
+        feedback: string | null;
+        id: string;
+        title: string;
+        question: string;
+        motivation: string | null;
+        reward: _prisma_client.Prisma.JsonValue;
+        createdAt: Date;
+        updatedAt: Date;
+        options: _prisma_client.LearningAnswerOption[];
+    };
+    state: LearningElementState;
+    solution: string | null;
+} | null>;
+interface AttemptLearningElementArgs {
+    elementId: string;
+    selection: string;
+}
+declare function attemptLearningElement(args: AttemptLearningElementArgs, ctx: Context): Promise<{
+    id: string;
+    pointsAchieved: number;
+    pointsMax: number;
+    element: {
+        id: string;
+        feedback: string | null;
+    };
+    player: any;
+} | null>;
+interface MarkStoryElementArgs {
+    elementId: string;
+}
+declare function markStoryElement(args: MarkStoryElementArgs, ctx: Context): Promise<_prisma_client.Player | null>;
+interface GetPlayerTransactionsArgs {
+}
+declare function getPlayerTransactions(args: GetPlayerTransactionsArgs, ctx: Context): Promise<_prisma_client.PlayerAction[]>;
+declare function getPlayerResults(args: any, ctx: Context): Promise<(_prisma_client.PlayerResult & {
+    period: _prisma_client.Period;
+    segment: _prisma_client.PeriodSegment | null;
+    player: _prisma_client.Player;
+})[]>;
+declare function getPastResults(args: any, ctx: Context): Promise<(_prisma_client.PlayerResult & {
+    period: _prisma_client.Period;
+    player: _prisma_client.Player;
+})[] | null>;
+declare function updateReadyState(args: any, ctx: Context): Promise<_prisma_client.Player>;
+
+declare const PlayService_performAction: typeof performAction;
+declare const PlayService_saveDecisions: typeof saveDecisions;
+declare const PlayService_getPlayerResult: typeof getPlayerResult;
+declare const PlayService_getPlayerData: typeof getPlayerData;
+declare const PlayService_getLearningElement: typeof getLearningElement;
+declare const PlayService_attemptLearningElement: typeof attemptLearningElement;
+declare const PlayService_markStoryElement: typeof markStoryElement;
+declare const PlayService_getPlayerTransactions: typeof getPlayerTransactions;
+declare const PlayService_getPlayerResults: typeof getPlayerResults;
+declare const PlayService_getPastResults: typeof getPastResults;
+declare const PlayService_updateReadyState: typeof updateReadyState;
+declare namespace PlayService {
+  export {
+    PlayService_performAction as performAction,
+    PlayService_saveDecisions as saveDecisions,
+    PlayService_getPlayerResult as getPlayerResult,
+    PlayService_getPlayerData as getPlayerData,
+    PlayService_getLearningElement as getLearningElement,
+    PlayService_attemptLearningElement as attemptLearningElement,
+    PlayService_markStoryElement as markStoryElement,
+    PlayService_getPlayerTransactions as getPlayerTransactions,
+    PlayService_getPlayerResults as getPlayerResults,
+    PlayService_getPastResults as getPastResults,
+    PlayService_updateReadyState as updateReadyState,
+  };
+}
+
+export { AccountService, Action, BaseGlobalNotificationType, BaseUserNotificationType, CtxWithFacts, CtxWithFactsAndSchema, CtxWithPrisma, Event, EventService, GameService, LearningElementState, Notification, Output, PlayService, UserRole };