@excali-boards/boards-api-client 1.1.51 → 1.1.53

package/dist/src/classes/auth.d.ts

@@ -0,0 +1,48 @@
+import { BoardsManager } from '../core/manager';
+import { CreateSessionInput } from './sessions';
+import { DBUserPartialType } from '../external/vars';
+import { WithHeaders } from '../types';
+export declare class APIAuth {
+    private web;
+    constructor(web: BoardsManager);
+    authenticate({ auth, body, ...rest }: AuthFunctionsInput['authenticate']): Promise<import("..").WebResponse<{
+        avatarUrl: string | null;
+        boardPermissions: {
+            boardId: string;
+            role: import("../../prisma/generated").$Enums.BoardRole;
+        }[];
+        categoryPermissions: {
+            categoryId: string;
+            role: import("../../prisma/generated").$Enums.CategoryRole;
+        }[];
+        displayName: string;
+        email: string;
+        groupPermissions: {
+            groupId: string;
+            role: import("../../prisma/generated").$Enums.GroupRole;
+        }[];
+        invitedBy: string | null;
+        loginMethods: {
+            platform: import("../../prisma/generated").$Enums.Platforms;
+            platformEmail: string;
+        }[];
+        mainGroupId: string | null;
+        mainLoginType: import("../../prisma/generated").$Enums.Platforms;
+        registrationMethod: import("../../prisma/generated").$Enums.RegistrationMethod;
+        userId: string;
+    }>>;
+}
+export type AuthFunctionsInput = WithHeaders<{
+    'authenticate': {
+        auth: string;
+        body: CreateSessionInput & {
+            refreshProfile?: boolean;
+        };
+    };
+}>;
+export type AuthOutput = DBUserPartialType & {
+    sessions: {
+        dbId: string;
+        lastUsed: Date;
+    }[];
+};

package/dist/src/classes/auth.js

@@ -0,0 +1,12 @@
+export class APIAuth {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    async authenticate({ auth, body, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth, body, ...rest,
+            endpoint: this.web.qp('/auth/authenticate'),
+        });
+    }
+}

package/dist/src/classes/boards.d.ts

@@ -0,0 +1,99 @@
+import { AccessLevel, AllRooms, NameInput, SingleOutput } from '../external/types';
+import { BoardType } from '../../prisma/generated/default';
+import { BoardsManager } from '../core/manager';
+import { WithHeaders } from '../types';
+export declare class APIBoards {
+    private web;
+    constructor(web: BoardsManager);
+    getBoards({ auth, categoryId, groupId, ...rest }: BoardsFunctionsInput['getBoards']): Promise<import("..").WebResponse<GetBoardOutput[]>>;
+    getBoard({ auth, categoryId, groupId, boardId, ...rest }: BoardsFunctionsInput['getBoard']): Promise<import("..").WebResponse<GetBoardOutput>>;
+    updateBoard({ auth, categoryId, groupId, boardId, body, ...rest }: BoardsFunctionsInput['updateBoard']): Promise<import("..").WebResponse<string>>;
+    moveBoard({ auth, categoryId, groupId, boardId, body, ...rest }: BoardsFunctionsInput['moveBoard']): Promise<import("..").WebResponse<MoveBoardOutput>>;
+    scheduleBoardDeletion({ auth, categoryId, groupId, boardId, ...rest }: BoardsFunctionsInput['scheduleBoardDeletion']): Promise<import("..").WebResponse<string>>;
+    forceDeleteBoard({ auth, categoryId, groupId, boardId, ...rest }: BoardsFunctionsInput['scheduleBoardDeletion']): Promise<import("..").WebResponse<string>>;
+    cancelBoardDeletion({ auth, categoryId, groupId, boardId, ...rest }: BoardsFunctionsInput['cancelBoardDeletion']): Promise<import("..").WebResponse<string>>;
+    getBoardRoomData({ auth, categoryId, groupId, boardId, ...rest }: BoardsFunctionsInput['getRoomData']): Promise<import("..").WebResponse<AllRooms>>;
+    kickUserFromRoom({ auth, categoryId, groupId, boardId, userId, ...rest }: BoardsFunctionsInput['kickUserFromRoom']): Promise<import("..").WebResponse<string>>;
+}
+export type BoardsFunctionsInput = WithHeaders<{
+    'getBoards': {
+        auth: string;
+        categoryId: string;
+        groupId: string;
+    };
+    'getBoard': {
+        auth: string;
+        categoryId: string;
+        groupId: string;
+        boardId: string;
+    };
+    'updateBoard': {
+        auth: string;
+        categoryId: string;
+        groupId: string;
+        boardId: string;
+        body: NameInput;
+    };
+    'moveBoard': {
+        auth: string;
+        categoryId: string;
+        groupId: string;
+        boardId: string;
+        body: MoveBoardInput;
+    };
+    'scheduleBoardDeletion': {
+        auth: string;
+        categoryId: string;
+        groupId: string;
+        boardId: string;
+    };
+    'cancelBoardDeletion': {
+        auth: string;
+        categoryId: string;
+        groupId: string;
+        boardId: string;
+    };
+    'getRoomData': {
+        auth: string;
+        categoryId: string;
+        groupId: string;
+        boardId: string;
+    };
+    'kickUserFromRoom': {
+        auth: string;
+        categoryId: string;
+        groupId: string;
+        boardId: string;
+        userId: string;
+    };
+}>;
+export type GetBoardOutput = {
+    group: SingleOutput;
+    category: SingleOutput;
+    board: SingleOutput & {
+        type: BoardType;
+        dataUrl: string;
+        hasFlashcards: boolean;
+        totalSizeBytes: number;
+        accessLevel: AccessLevel;
+        scheduledForDeletion: Date | null;
+        files: {
+            fileId: string;
+            mimeType: string;
+            createdAt: Date;
+            sizeBytes: number;
+            fileUrl: string;
+        }[];
+    };
+};
+export type GetFileOutput = ReadableStream | Blob;
+export type MoveBoardInput = {
+    targetCategoryId: string;
+    targetIndex?: number;
+};
+export type MoveBoardOutput = {
+    boardId: string;
+    categoryId: string;
+    groupId: string;
+    index: number;
+};

package/dist/src/classes/boards.js

@@ -0,0 +1,62 @@
+export class APIBoards {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    async getBoards({ auth, categoryId, groupId, ...rest }) {
+        return await this.web.request({
+            method: 'GET', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}`),
+        });
+    }
+    async getBoard({ auth, categoryId, groupId, boardId, ...rest }) {
+        return await this.web.request({
+            method: 'GET', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}`),
+        });
+    }
+    async updateBoard({ auth, categoryId, groupId, boardId, body, ...rest }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}`),
+        });
+    }
+    async moveBoard({ auth, categoryId, groupId, boardId, body, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth, body, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/move`),
+        });
+    }
+    async scheduleBoardDeletion({ auth, categoryId, groupId, boardId, ...rest }) {
+        return await this.web.request({
+            method: 'DELETE', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}`),
+        });
+    }
+    async forceDeleteBoard({ auth, categoryId, groupId, boardId, ...rest }) {
+        return await this.web.request({
+            method: 'DELETE', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}?force=true`),
+        });
+    }
+    async cancelBoardDeletion({ auth, categoryId, groupId, boardId, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/cancel-deletion`),
+        });
+    }
+    async getBoardRoomData({ auth, categoryId, groupId, boardId, ...rest }) {
+        return await this.web.request({
+            method: 'GET', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/room`),
+        });
+    }
+    async kickUserFromRoom({ auth, categoryId, groupId, boardId, userId, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/room-kick`, {
+                userId,
+            }),
+        });
+    }
+}

package/dist/src/classes/calendar.d.ts

@@ -0,0 +1,84 @@
+import { SingleOutput } from '../external/types';
+import { BoardsManager } from '../core/manager';
+import { WithHeaders } from '../types';
+export declare class APICalendar {
+    private web;
+    constructor(web: BoardsManager);
+    getCalendar({ auth, groupId, ...rest }: CalendarFunctionsInput['getCalendar']): Promise<import("..").WebResponse<GetCalendarResponse>>;
+    getHolidays({ auth, countryCode, year, ...rest }: CalendarFunctionsInput['getHolidays']): Promise<import("..").WebResponse<FormattedHoliday[]>>;
+    updateGroupCalendarCode({ auth, groupId, calCode, ...rest }: CalendarFunctionsInput['updateGroupCalendarCode']): Promise<import("..").WebResponse<string>>;
+    createEvent({ auth, groupId, event, ...rest }: CalendarFunctionsInput['createEvent']): Promise<import("..").WebResponse<string>>;
+    updateEvent({ auth, groupId, eventId, event, ...rest }: CalendarFunctionsInput['updateEvent']): Promise<import("..").WebResponse<string>>;
+    deleteEvent({ auth, groupId, eventId, ...rest }: CalendarFunctionsInput['deleteEvent']): Promise<import("..").WebResponse<string>>;
+}
+export type CalendarFunctionsInput = WithHeaders<{
+    'getCalendar': {
+        auth: string;
+        groupId: string;
+    };
+    'getHolidays': {
+        auth: string;
+        countryCode: string;
+        year: number;
+    };
+    'createEvent': {
+        auth: string;
+        groupId: string;
+        event: EventObject;
+    };
+    'updateGroupCalendarCode': {
+        auth: string;
+        groupId: string;
+        calCode: string | null;
+    };
+    'updateEvent': {
+        auth: string;
+        groupId: string;
+        eventId: string;
+        event: Partial<EventObject>;
+    };
+    'deleteEvent': {
+        auth: string;
+        groupId: string;
+        eventId: string;
+    };
+}>;
+export type EventObject = {
+    title: string;
+    start: Date;
+    end: Date;
+    color: string;
+    description?: string;
+    where?: string;
+};
+export type GetCalendarResponse = {
+    group: SingleOutput & {
+        calendarCode: string | null;
+    };
+    events: CalendarEvent[];
+};
+export type CalendarEvent = {
+    id: string;
+    title: string;
+    color: string;
+    description: string | null;
+    where: string | null;
+    start: Date;
+    end: Date;
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy: {
+        displayName: string;
+        avatarUrl: string | null;
+    };
+};
+export type ClosedStatus = 'Public' | 'Bank' | 'School' | 'Authorities' | 'Optional' | 'Observance';
+export type FormattedHoliday = {
+    id: string;
+    title: string;
+    start: Date;
+    end: Date;
+    color: string;
+    description: string;
+    types: ClosedStatus[];
+};

package/dist/src/classes/calendar.js

@@ -0,0 +1,45 @@
+export class APICalendar {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    async getCalendar({ auth, groupId, ...rest }) {
+        return await this.web.request({
+            method: 'GET', auth, ...rest,
+            endpoint: `/groups/${groupId}/calendar`,
+        });
+    }
+    async getHolidays({ auth, countryCode, year, ...rest }) {
+        return await this.web.request({
+            method: 'GET', auth, ...rest,
+            endpoint: `/holidays/${countryCode}/${year}`,
+        });
+    }
+    async updateGroupCalendarCode({ auth, groupId, calCode, ...rest }) {
+        return await this.web.request({
+            method: 'PATCH', auth, ...rest,
+            endpoint: `/groups/${groupId}/calendar`,
+            body: { calCode },
+        });
+    }
+    async createEvent({ auth, groupId, event, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth, ...rest,
+            endpoint: `/groups/${groupId}/calendar`,
+            body: event,
+        });
+    }
+    async updateEvent({ auth, groupId, eventId, event, ...rest }) {
+        return await this.web.request({
+            method: 'PATCH', auth, ...rest,
+            endpoint: `/groups/${groupId}/calendar/${eventId}`,
+            body: event,
+        });
+    }
+    async deleteEvent({ auth, groupId, eventId, ...rest }) {
+        return await this.web.request({
+            method: 'DELETE', auth, ...rest,
+            endpoint: `/groups/${groupId}/calendar/${eventId}`,
+        });
+    }
+}

package/dist/src/classes/categories.d.ts

@@ -0,0 +1,75 @@
+import { BoardInput, NameInput, SingleOutput } from '../external/types';
+import { BoardsManager } from '../core/manager';
+import { GetBoardOutput } from './boards';
+import { WithHeaders } from '../types';
+export declare class APICategories {
+    private web;
+    constructor(web: BoardsManager);
+    getCategories({ auth, groupId, ...rest }: CategoriesFunctionsInput['getCategories']): Promise<import("..").WebResponse<GetCategoriesOutput>>;
+    getCategory({ auth, groupId, categoryId, ...rest }: CategoriesFunctionsInput['getCategory']): Promise<import("..").WebResponse<GetCategoryOutput>>;
+    createBoardInCategory({ auth, groupId, categoryId, body, ...rest }: CategoriesFunctionsInput['createBoardInCategory']): Promise<import("..").WebResponse<string>>;
+    updateCategory({ auth, groupId, categoryId, body, ...rest }: CategoriesFunctionsInput['updateCategory']): Promise<import("..").WebResponse<string>>;
+    moveCategory({ auth, groupId, categoryId, body, ...rest }: CategoriesFunctionsInput['moveCategory']): Promise<import("..").WebResponse<MoveCategoryOutput>>;
+    reorderBoardsInCategory({ auth, groupId, categoryId, body, ...rest }: CategoriesFunctionsInput['reorderBoards']): Promise<import("..").WebResponse<string>>;
+    deleteCategory({ auth, groupId, categoryId, ...rest }: CategoriesFunctionsInput['deleteCategory']): Promise<import("..").WebResponse<string>>;
+}
+export type CategoriesFunctionsInput = WithHeaders<{
+    'getCategories': {
+        auth: string;
+        groupId: string;
+    };
+    'getCategory': {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+    };
+    'createBoardInCategory': {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        body: BoardInput & {
+            copyPermissionsFromBoardId?: string;
+        };
+    };
+    'updateCategory': {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        body: NameInput;
+    };
+    'moveCategory': {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        body: MoveCategoryInput;
+    };
+    'reorderBoards': {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        body: string[];
+    };
+    'deleteCategory': {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+    };
+}>;
+export type GetCategoriesOutput = (SingleOutput & {
+    boards: number;
+    group: SingleOutput;
+})[];
+export type GetCategoryOutput = {
+    group: SingleOutput;
+    category: SingleOutput;
+    boards: Omit<GetBoardOutput['board'], 'files'>[];
+};
+export type MoveCategoryInput = {
+    targetGroupId: string;
+    targetIndex?: number;
+};
+export type MoveCategoryOutput = {
+    categoryId: string;
+    groupId: string;
+    index: number;
+};

package/dist/src/classes/categories.js

@@ -0,0 +1,50 @@
+// Data.
+export class APICategories {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getCategories({ auth, groupId, ...rest }) {
+        return await this.web.request({
+            method: 'GET', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}`),
+        });
+    }
+    async getCategory({ auth, groupId, categoryId, ...rest }) {
+        return await this.web.request({
+            method: 'GET', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}`),
+        });
+    }
+    async createBoardInCategory({ auth, groupId, categoryId, body, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth, body, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards`),
+        });
+    }
+    async updateCategory({ auth, groupId, categoryId, body, ...rest }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}`),
+        });
+    }
+    async moveCategory({ auth, groupId, categoryId, body, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth, body, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/move`),
+        });
+    }
+    async reorderBoardsInCategory({ auth, groupId, categoryId, body, ...rest }) {
+        return await this.web.request({
+            method: 'PUT', auth, body, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards`),
+        });
+    }
+    async deleteCategory({ auth, groupId, categoryId, ...rest }) {
+        return await this.web.request({
+            method: 'DELETE', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}`),
+        });
+    }
+}

package/dist/src/classes/files.d.ts

@@ -0,0 +1,45 @@
+import { BoardsManager } from '../core/manager';
+import { WithHeaders } from '../types';
+export declare class APIFiles {
+    private web;
+    constructor(web: BoardsManager);
+    uploadBase64Files({ auth, boardId, files, ...rest }: FilesFunctionsInput['uploadBase64Files']): Promise<import("..").WebResponse<FileUploadResponse>>;
+    uploadRawFiles({ auth, boardId, files, ...rest }: FilesFunctionsInput['uploadRawFiles']): Promise<import("..").WebResponse<FileUploadResponse>>;
+    deleteFiles({ auth, boardId, fileIds, ...rest }: FilesFunctionsInput['deleteFiles']): Promise<import("..").WebResponse<string>>;
+}
+export type FilesFunctionsInput = WithHeaders<{
+    'uploadBase64Files': {
+        auth: string;
+        boardId: string;
+        files: Base64FileInput;
+    };
+    'uploadRawFiles': {
+        auth: string;
+        boardId: string;
+        files: RawFileInput[];
+    };
+    'deleteFiles': {
+        auth: string;
+        boardId: string;
+        fileIds: string[];
+    };
+}>;
+export type Base64FileInput = {
+    id: string;
+    data: string;
+    mimeType: string;
+}[];
+export type RawFileInput = {
+    file: File;
+    clientId: string;
+};
+export type FileUploadResponse = {
+    success: number;
+    failed: number;
+    files: FileUrlMapping[];
+};
+export type FileUrlMapping = {
+    clientId: string;
+    serverId: string;
+    url: string;
+};

package/dist/src/classes/files.js

@@ -0,0 +1,31 @@
+export class APIFiles {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    async uploadBase64Files({ auth, boardId, files, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth, ...rest,
+            endpoint: `/files/${boardId}/base64`,
+            body: files,
+        });
+    }
+    async uploadRawFiles({ auth, boardId, files, ...rest }) {
+        const formData = new FormData();
+        for (const file of files) {
+            formData.append(`file-${file.clientId}`, file.file);
+        }
+        return await this.web.request({
+            method: 'POST', auth, ...rest,
+            endpoint: `/files/${boardId}/raw`,
+            body: formData,
+        });
+    }
+    async deleteFiles({ auth, boardId, fileIds, ...rest }) {
+        return await this.web.request({
+            method: 'DELETE', auth, ...rest,
+            endpoint: `/files/${boardId}/delete`,
+            body: fileIds,
+        });
+    }
+}

package/dist/src/classes/flashcards.d.ts

@@ -0,0 +1,120 @@
+import { SingleOutput } from '../external/types';
+import { BoardsManager } from '../core/manager';
+import { WithHeaders } from '../types';
+export declare class APIFlashcards {
+    private web;
+    constructor(web: BoardsManager);
+    getDeck({ auth, groupId, categoryId, boardId, ...rest }: FlashcardsFunctionsInput['getDeck']): Promise<import("..").WebResponse<FlashcardDeckResponse>>;
+    initializeDeck({ auth, groupId, categoryId, boardId, ...rest }: FlashcardsFunctionsInput['initializeDeck']): Promise<import("..").WebResponse<string>>;
+    destroyDeck({ auth, groupId, categoryId, boardId, ...rest }: FlashcardsFunctionsInput['destroyDeck']): Promise<import("..").WebResponse<string>>;
+    createCards({ auth, groupId, categoryId, boardId, body, ...rest }: FlashcardsFunctionsInput['createCards']): Promise<import("..").WebResponse<string>>;
+    updateCards({ auth, groupId, categoryId, boardId, body, ...rest }: FlashcardsFunctionsInput['updateCards']): Promise<import("..").WebResponse<string>>;
+    deleteCards({ auth, groupId, categoryId, boardId, body, ...rest }: FlashcardsFunctionsInput['deleteCards']): Promise<import("..").WebResponse<string>>;
+    overrideCards({ auth, groupId, categoryId, boardId, body, ...rest }: FlashcardsFunctionsInput['overrideCards']): Promise<import("..").WebResponse<string>>;
+    updateProgress({ auth, groupId, categoryId, boardId, body, ...rest }: FlashcardsFunctionsInput['updateProgress']): Promise<import("..").WebResponse<string>>;
+    resetProgress({ auth, groupId, categoryId, boardId, ...rest }: FlashcardsFunctionsInput['resetProgress']): Promise<import("..").WebResponse<string>>;
+    reorderCards({ auth, groupId, categoryId, boardId, body, ...rest }: FlashcardsFunctionsInput['reorderCards']): Promise<import("..").WebResponse<string>>;
+}
+export type FlashcardsFunctionsInput = WithHeaders<{
+    getDeck: {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        boardId: string;
+    };
+    initializeDeck: {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        boardId: string;
+    };
+    destroyDeck: {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        boardId: string;
+    };
+    createCards: {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        boardId: string;
+        body: CardInput[];
+    };
+    updateCards: {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        boardId: string;
+        body: CardUpdateInput[];
+    };
+    deleteCards: {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        boardId: string;
+        body: string[];
+    };
+    overrideCards: {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        boardId: string;
+        body: CardInput[];
+    };
+    updateProgress: {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        boardId: string;
+        body: ProgressInput;
+    };
+    resetProgress: {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        boardId: string;
+    };
+    reorderCards: {
+        auth: string;
+        groupId: string;
+        categoryId: string;
+        boardId: string;
+        body: string[];
+    };
+}>;
+export type CardInput = {
+    front: string;
+    back: string;
+};
+export type CardUpdateInput = {
+    id: string;
+    front?: string;
+    back?: string;
+};
+export type ProgressInput = {
+    currentIndex: number;
+    completed?: boolean;
+};
+export type FlashcardDeckResponse = {
+    board: SingleOutput;
+    deck: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+    };
+    cards: FlashcardCard[];
+    progress: {
+        completed: boolean;
+        lastStudied: Date;
+        currentIndex: number;
+    } | null;
+};
+export type FlashcardCard = {
+    id: string;
+    front: string;
+    back: string;
+    index: number;
+    createdAt: Date;
+    updatedAt: Date;
+};