@vestcards/server-types 1.2.0 → 1.4.0

package/dist/apps/server/src/modules/auth/lib.d.ts

@@ -1,8 +1,10 @@
 import { UserRole } from '@vestcards/shared';
 import { type BetterAuthOptions } from 'better-auth';
+import { mapAppleProfileToUser } from './profile';
 export declare const auth: import("better-auth").Auth<{
-    plugins: [{
+    plugins: ({
         id: "open-api";
+        version: string;
         endpoints: {
             generateOpenAPISchema: import("better-call").StrictEndpoint<"/open-api/generate-schema", {
                 method: "GET";
@@ -52,8 +54,9 @@ export declare const auth: import("better-auth").Auth<{
             }, Response>;
         };
         options: NoInfer<import("better-auth/plugins").OpenAPIOptions>;
-    }, {
+    } | {
         id: "expo";
+        version: string;
         init: (ctx: import("better-auth").AuthContext) => {
             options: {
                 trustedOrigins: string[];
@@ -71,10 +74,10 @@ export declare const auth: import("better-auth").Auth<{
         endpoints: {
             expoAuthorizationProxy: import("better-call").StrictEndpoint<"/expo-authorization-proxy", {
                 method: "GET";
-                query: import("better-auth").ZodObject<{
-                    authorizationURL: import("better-auth").ZodString;
-                    oauthState: import("better-auth").ZodOptional<import("better-auth").ZodString>;
-                }, import("better-auth").$strip>;
+                query: import("zod").ZodObject<{
+                    authorizationURL: import("zod").ZodString;
+                    oauthState: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
                 metadata: {
                     readonly scope: "server";
                 };
@@ -94,8 +97,9 @@ export declare const auth: import("better-auth").Auth<{
             }>;
         };
         options: import("@better-auth/expo").ExpoOptions | undefined;
-    }, {
+    } | {
         id: "bearer";
+        version: string;
         hooks: {
             before: {
                 matcher(context: import("better-auth").HookEndpointContext): boolean;
@@ -111,8 +115,9 @@ export declare const auth: import("better-auth").Auth<{
             }[];
         };
         options: import("better-auth/plugins").BearerOptions | undefined;
-    }, {
+    } | {
         id: "custom-session";
+        version: string;
         hooks: {
             after: {
                 matcher: (ctx: import("better-auth").HookEndpointContext) => boolean;
@@ -147,10 +152,10 @@ export declare const auth: import("better-auth").Auth<{
         endpoints: {
             getSession: import("better-call").StrictEndpoint<"/get-session", {
                 method: "GET";
-                query: import("better-auth").ZodOptional<import("better-auth").ZodObject<{
-                    disableCookieCache: import("better-auth").ZodOptional<import("better-auth").ZodUnion<[import("better-auth").ZodBoolean, import("better-auth").ZodPipe<import("better-auth").ZodString, import("better-auth").ZodTransform<boolean, string>>]>>;
-                    disableRefresh: import("better-auth").ZodOptional<import("better-auth").ZodBoolean>;
-                }, import("better-auth").$strip>>;
+                query: import("zod").ZodOptional<import("zod").ZodObject<{
+                    disableCookieCache: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodBoolean, import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<boolean, string>>]>>;
+                    disableRefresh: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>>;
                 metadata: {
                     CUSTOM_SESSION: boolean;
                     openapi: {
@@ -230,11 +235,11 @@ export declare const auth: import("better-auth").Auth<{
             };
         };
         options: import("better-auth/plugins").CustomSessionPluginOptions | undefined;
-    }];
+    })[];
     baseURL: string;
     basePath: string;
     database: (options: BetterAuthOptions) => import("better-auth").DBAdapter<BetterAuthOptions>;
-    secondaryStorage: import("better-auth").SecondaryStorage;
+    secondaryStorage: import("better-auth").SecondaryStorage | undefined;
     emailAndPassword: {
         enabled: true;
         autoSignIn: true;
@@ -293,6 +298,8 @@ export declare const auth: import("better-auth").Auth<{
         apple: {
             clientId: string;
             clientSecret: string;
+            appBundleIdentifier: string;
+            mapProfileToUser: typeof mapAppleProfileToUser;
         };
     };
     user: {
@@ -327,17 +334,38 @@ export declare const auth: import("better-auth").Auth<{
                     image?: string | null | undefined;
                 } & Record<string, unknown>) => Promise<{
                     data: {
+                        email: string;
                         entityId: string;
                         id: string;
                         createdAt: Date;
                         updatedAt: Date;
-                        email: string;
                         emailVerified: boolean;
                         name: string;
                         image?: string | null | undefined;
                     };
                 }>;
             };
+            update: {
+                before: (userData: Partial<{
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                }> & Record<string, unknown>) => Promise<{
+                    data: Partial<{
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    }> & Record<string, unknown>;
+                }>;
+            };
         };
         session: {
             create: {
@@ -366,14 +394,14 @@ export declare const auth: import("better-auth").Auth<{
         };
     };
     logger: {
-        log(level: "error" | "warn" | "info" | "debug", message: string, ...args: any[]): void;
+        log(level: "debug" | "info" | "warn" | "error", message: string, ...args: any[]): void;
     };
     advanced: {
         useSecureCookies: boolean;
         disableOriginCheck: true;
         cookiePrefix: string;
         defaultCookieAttributes: {
-            sameSite: "lax" | "none";
+            sameSite: "none" | "lax";
             secure: boolean;
         };
         database: {

package/dist/apps/server/src/modules/auth/profile.d.ts

@@ -0,0 +1,5 @@
+import type { AppleProfile } from 'better-auth/social-providers';
+export declare function mapAppleProfileToUser(profile: AppleProfile): {
+    name: string;
+    surname: string;
+};

package/dist/apps/server/src/modules/auth/utils.d.ts

@@ -1,4 +1,5 @@
 import type { BetterAuthOptions } from 'better-auth';
+export declare function generateAppleClientSecret(clientId: string, teamId: string, keyId: string, privateKey: string): Promise<string>;
 export declare function assertCredentialAccount(userId: string): Promise<void>;
 type SendVerificationEmail = NonNullable<BetterAuthOptions['emailVerification']>['sendVerificationEmail'];
 export declare const sendVerificationEmail: SendVerificationEmail;

package/dist/apps/server/src/modules/card/index.d.ts

@@ -445,6 +445,95 @@ export declare const cardModule: Elysia<"/v1/card", {
             };
         };
     };
+} & {
+    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;
+                        };
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};

package/dist/apps/server/src/modules/card/model.d.ts

@@ -1,4 +1,9 @@
 export declare namespace CardModel {
+    /**
+     * Whether a card counts as "to review" in the deck view.
+     * Uses end-of-day cutoff to match StudyService.getReviewCards behaviour.
+     */
+    function isCardToReview(state: string, suspended: boolean, due: Date | null, now?: Date): boolean;
     const reportBody: import("@sinclair/typebox").TObject<{
         cardId: import("@sinclair/typebox").TString;
         content: import("@sinclair/typebox").TString;
@@ -9,4 +14,16 @@ export declare namespace CardModel {
         cardId: import("@sinclair/typebox").TString;
     }>;
     type ReportQuery = typeof reportQuery.static;
+    const suspendBody: import("@sinclair/typebox").TObject<{
+        cardId: import("@sinclair/typebox").TString;
+    }>;
+    type SuspendBody = typeof suspendBody.static;
+    const suspendQuery: import("@sinclair/typebox").TObject<{
+        cardId: import("@sinclair/typebox").TString;
+    }>;
+    type SuspendQuery = typeof suspendQuery.static;
+    const userStateQuery: import("@sinclair/typebox").TObject<{
+        deckId: import("@sinclair/typebox").TString;
+    }>;
+    type UserStateQuery = typeof userStateQuery.static;
 }

package/dist/apps/server/src/modules/card/service.d.ts

@@ -1,6 +1,13 @@
 import type { CardDemand } from '@vestcards/db-core';
-import type { CardModel } from './model';
+import { CardModel } from './model';
 export declare abstract class CardService {
     static getReport(userId: string, cardId: string): Promise<CardDemand | null>;
+    static suspendCard(userId: string, cardId: string): Promise<boolean>;
+    static unsuspendCard(userId: string, cardId: string): Promise<boolean>;
+    static getUserState(userId: string, deckId: string): Promise<{
+        cardId: string;
+        suspended: boolean;
+        toReview: boolean;
+    }[]>;
     static reportCard(userId: string, body: CardModel.ReportBody): Promise<void>;
 }

package/dist/apps/server/src/modules/cron/cron.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/apps/server/src/modules/cron/index.d.ts

@@ -0,0 +1,53 @@
+import Elysia from 'elysia';
+export declare const cronModule: Elysia<"", {
+    decorator: {};
+    store: {
+        cron: Record<"expire-memberships", import("croner").Cron> & Record<"payment-expiry-reminder", import("croner").Cron>;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+} & {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+} & {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/apps/server/src/modules/cron/jobs/expire-memberships.d.ts

@@ -0,0 +1 @@
+export declare function expireMemberships(): Promise<void>;

package/dist/apps/server/src/modules/cron/jobs/payment-expiry-reminder.d.ts

@@ -0,0 +1 @@
+export declare function sendPaymentExpiryReminders(): Promise<void>;

package/dist/apps/server/src/modules/deck/index.d.ts

@@ -417,6 +417,22 @@ export declare const deckModule: Elysia<"/v1/decks", {
             };
         };
     };
+} & {
+    v1: {
+        decks: {
+            recommended: {
+                get: {
+                    body: {};
+                    params: {};
+                    query: {};
+                    headers: {};
+                    response: {
+                        200: import("@vestcards/shared").IDeck[];
+                    };
+                };
+            };
+        };
+    };
 } & {
     v1: {
         decks: {
@@ -426,7 +442,9 @@ export declare const deckModule: Elysia<"/v1/decks", {
                     params: {
                         deckId: string;
                     };
-                    query: {};
+                    query: {
+                        preview?: boolean | undefined;
+                    };
                     headers: {};
                     response: {
                         200: import("@vestcards/shared").IDeckDetail;

package/dist/apps/server/src/modules/deck/model.d.ts

@@ -19,6 +19,10 @@ export declare namespace DeckModel {
         deckId: import("@sinclair/typebox").TString;
     }>;
     type DeckIdParams = typeof deckIdParams.static;
+    const deckDetailQuery: import("@sinclair/typebox").TObject<{
+        preview: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    }>;
+    type DeckDetailQuery = typeof deckDetailQuery.static;
     const topicSubjectParams: import("@sinclair/typebox").TObject<{
         subject: import("@sinclair/typebox").TString;
     }>;

package/dist/apps/server/src/modules/deck/service.d.ts

@@ -3,6 +3,10 @@ import { type Paginated } from '../../utils/api';
 import { DeckModel } from './model';
 export declare abstract class DeckService {
     static getAllDecks(filters: DeckModel.DeckListFilters, loggedUserId?: string): Promise<Paginated<IDeck>>;
-    static getDeck(deckId: string): Promise<IDeckDetail>;
+    static getDeck(deckId: string, options?: {
+        cardLimit?: number;
+    }): Promise<IDeckDetail>;
+    static getRecommendedDecks(_userId: string, canReadPremiumDecks: boolean): Promise<IDeck[]>;
+    private static mapDeckOwnerInfo;
     static getOwnerInfoById(ownerId: string): Promise<IOwnerInfo>;
 }