@vestcards/server-types 1.2.0 → 1.4.0

package/dist/apps/server/src/app.d.ts

@@ -503,6 +503,95 @@ declare const app: Elysia<"", {
             };
         };
     };
+} & {
+    v1: {
+        card: {
+            suspend: {
+                post: {
+                    body: {
+                        cardId: string;
+                    };
+                    params: {};
+                    query: {};
+                    headers: {};
+                    response: {
+                        200: {
+                            success: boolean;
+                        };
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        card: {
+            suspend: {
+                delete: {
+                    body: {};
+                    params: {};
+                    query: {
+                        cardId: string;
+                    };
+                    headers: {};
+                    response: {
+                        200: {
+                            success: boolean;
+                        };
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        card: {
+            "user-state": {
+                get: {
+                    body: {};
+                    params: {};
+                    query: {
+                        deckId: string;
+                    };
+                    headers: {};
+                    response: {
+                        200: {
+                            cardId: string;
+                            suspended: boolean;
+                            toReview: boolean;
+                        }[];
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
 } & {
     v1: {
         decks: {
@@ -574,6 +663,22 @@ declare const app: Elysia<"", {
             };
         };
     };
+} & {
+    v1: {
+        decks: {
+            recommended: {
+                get: {
+                    body: {};
+                    params: {};
+                    query: {};
+                    headers: {};
+                    response: {
+                        200: import("@vestcards/shared").IDeck[];
+                    };
+                };
+            };
+        };
+    };
 } & {
     v1: {
         decks: {
@@ -583,7 +688,9 @@ declare const app: Elysia<"", {
                     params: {
                         deckId: string;
                     };
-                    query: {};
+                    query: {
+                        preview?: boolean | undefined;
+                    };
                     headers: {};
                     response: {
                         200: import("@vestcards/shared").IDeckDetail;
@@ -1054,6 +1161,134 @@ declare const app: Elysia<"", {
             };
         };
     };
+} & {
+    v1: {
+        ranking: {
+            v1: {
+                auth: {
+                    "validate-reset-token": {
+                        get: {
+                            body: unknown;
+                            params: {};
+                            query: {
+                                token: string;
+                            };
+                            headers: unknown;
+                            response: {
+                                200: {
+                                    valid: boolean;
+                                };
+                                422: {
+                                    type: "validation";
+                                    on: string;
+                                    summary?: string;
+                                    message?: string;
+                                    found?: unknown;
+                                    property?: string;
+                                    expected?: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        ranking: {
+            get: {
+                body: {};
+                params: {};
+                query: {};
+                headers: {};
+                response: {
+                    200: import("./modules/ranking/model").RankingData;
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        stats: {
+            v1: {
+                auth: {
+                    "validate-reset-token": {
+                        get: {
+                            body: unknown;
+                            params: {};
+                            query: {
+                                token: string;
+                            };
+                            headers: unknown;
+                            response: {
+                                200: {
+                                    valid: boolean;
+                                };
+                                422: {
+                                    type: "validation";
+                                    on: string;
+                                    summary?: string;
+                                    message?: string;
+                                    found?: unknown;
+                                    property?: string;
+                                    expected?: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        stats: {
+            home: {
+                get: {
+                    body: {};
+                    params: {};
+                    query: {};
+                    headers: {};
+                    response: {
+                        200: import("./modules/stats/model").StatsModel.HomePageStats;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        stats: {
+            streak: {
+                get: {
+                    body: {};
+                    params: {};
+                    query: {};
+                    headers: {};
+                    response: {
+                        200: import("./modules/stats/model").StatsModel.StreakResult;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        stats: {
+            dashboard: {
+                get: {
+                    body: {};
+                    params: {};
+                    query: {};
+                    headers: {};
+                    response: {
+                        200: import("./modules/stats/model").StatsModel.DashboardStats;
+                    };
+                };
+            };
+        };
+    };
 } & {
     v1: {
         user: {
@@ -1097,20 +1332,7 @@ declare const app: Elysia<"", {
                     query: {};
                     headers: {};
                     response: {
-                        200: {
-                            id: string;
-                            name: string;
-                            surname: string;
-                            email: string;
-                            image: string | null;
-                            role: import("@vestcards/shared").UserRole;
-                            goal: string | null;
-                            learnDailyLimit: number | null;
-                            universityId: number | null;
-                            universityName: string | null;
-                            courseId: number | null;
-                            courseName: string | null;
-                        };
+                        200: import("@vestcards/shared").IUserProfile | null;
                     };
                 };
             };
@@ -1123,8 +1345,10 @@ declare const app: Elysia<"", {
                 patch: {
                     body: {
                         university?: number | null | undefined;
+                        timezone?: string | undefined;
                         course?: number | null | undefined;
-                        learnDailyLimit?: number | undefined;
+                        learnDailyLimit?: number | null | undefined;
+                        newCardsPerDeckDailyLimit?: number | null | undefined;
                     };
                     params: {};
                     query: {};
@@ -1165,6 +1389,68 @@ declare const app: Elysia<"", {
             };
         };
     };
+} & {
+    v1: {
+        user: {
+            account: {
+                "delete-request": {
+                    post: {
+                        body: {
+                            email: string;
+                        };
+                        params: {};
+                        query: {};
+                        headers: {};
+                        response: {
+                            200: {
+                                success: boolean;
+                            };
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        user: {
+            account: {
+                "confirm-delete": {
+                    post: {
+                        body: {
+                            token: string;
+                        };
+                        params: {};
+                        query: {};
+                        headers: {};
+                        response: {
+                            200: {
+                                success: boolean;
+                            };
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
 } & {
     v1: {
         user: {
@@ -1184,6 +1470,33 @@ declare const app: Elysia<"", {
             };
         };
     };
+} & {
+    v1: {
+        user: {
+            password: {
+                post: {
+                    body: {
+                        newPassword: string;
+                        currentPassword: string;
+                    };
+                    params: {};
+                    query: {};
+                    headers: {};
+                    response: {
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
 } & {
     v1: {
         user: {
@@ -1192,6 +1505,7 @@ declare const app: Elysia<"", {
                     body: {
                         university?: number | undefined;
                         dayTimeReminder?: string | undefined;
+                        timezone?: string | undefined;
                         course?: number | undefined;
                         goal: string;
                         hoursStudied: string;
@@ -1279,6 +1593,113 @@ declare const app: Elysia<"", {
             };
         };
     };
+} & {
+    v1: {
+        vesty: {
+            v1: {
+                auth: {
+                    "validate-reset-token": {
+                        get: {
+                            body: unknown;
+                            params: {};
+                            query: {
+                                token: string;
+                            };
+                            headers: unknown;
+                            response: {
+                                200: {
+                                    valid: boolean;
+                                };
+                                422: {
+                                    type: "validation";
+                                    on: string;
+                                    summary?: string;
+                                    message?: string;
+                                    found?: unknown;
+                                    property?: string;
+                                    expected?: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        vesty: {
+            chat: {
+                post: {
+                    body: {
+                        data?: {} | undefined;
+                        messages: {
+                            role: "user" | "assistant";
+                            parts: any[];
+                        }[];
+                    };
+                    params: {};
+                    query: {};
+                    headers: {};
+                    response: {
+                        200: Response;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        vesty: {
+            "generate-deck": {
+                post: {
+                    body: {
+                        prompt: string;
+                    };
+                    params: {};
+                    query: {};
+                    headers: {};
+                    response: {
+                        200: import("./modules/vesty/model").VestyModel.GeneratedDeck;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    v1: {
+        vesty: {
+            insights: {
+                get: {
+                    body: {};
+                    params: {};
+                    query: {};
+                    headers: {};
+                    response: {
+                        200: import("./modules/vesty/model").VestyModel.InsightsResult;
+                    };
+                };
+            };
+        };
+    };
 } & {
     health: {
         get: {

package/dist/apps/server/src/config/env.d.ts

@@ -8,9 +8,15 @@ export declare const config: {
     googleClientId: string;
     googleClientSecret: string;
     appleClientId: string;
-    appleClientSecret: string;
+    appleTeamId: string;
+    appleKeyId: string;
+    applePrivateKey: string;
+    appleAppBundleIdentifier: string;
+    geminiApiKey: string;
     port: number;
     nodeEnv: string;
     corsOrigins: string | undefined;
     debug: boolean;
+    posthogApiKey: string;
+    posthogHost: string;
 };

package/dist/apps/server/src/lib/metrics.d.ts

@@ -0,0 +1,4 @@
+import { Counter, Histogram, register } from 'prom-client';
+export declare const httpRequestDuration: Histogram<"route" | "method" | "status_code">;
+export declare const httpRequestTotal: Counter<"route" | "method" | "status_code">;
+export { register };

package/dist/apps/server/src/lib/posthog.d.ts

@@ -0,0 +1,2 @@
+import { PostHog } from 'posthog-node';
+export declare const posthog: PostHog;

package/dist/apps/server/src/libs/mappers.d.ts

@@ -0,0 +1,5 @@
+import type { CardReview, NewCardReview, NewReviewLog } from '@vestcards/db-core';
+import type { ICardReview, IReviewLog } from '@vestcards/shared';
+export declare function cardReviewToICardReview(row: CardReview): ICardReview;
+export declare function iCardReviewToNewCardReview(card: ICardReview): NewCardReview;
+export declare function iReviewLogToNewReviewLog(log: IReviewLog): NewReviewLog;

package/dist/apps/server/src/middleware/errorHandler.d.ts

@@ -1,4 +1,4 @@
-import type { ErrorHandler } from 'elysia';
+import { type ErrorHandler } from 'elysia';
 /**
  * Global error handler returning Response.json() so the return type
  * is NOT merged into Eden treaty's success union — errors stay in

package/dist/apps/server/src/middleware/logger.d.ts

@@ -1,29 +1,12 @@
-import { Elysia } from 'elysia';
-export declare const requestLogger: Elysia<"", {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
-    typebox: {};
-    error: {};
-}, {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-}, {}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}>;
+export declare function onRequest({ request, store }: {
+    request: Request;
+    store: Record<string, unknown>;
+}): Promise<void>;
+export declare function onAfterResponse({ request, responseValue, set, store, }: {
+    request: Request;
+    responseValue: unknown;
+    set: {
+        status?: number | string;
+    };
+    store: Record<string, unknown>;
+}): void;