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

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;
+};

package/dist/src/classes/flashcards.js

@@ -0,0 +1,68 @@
+// Data.
+export class APIFlashcards {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getDeck({ auth, groupId, categoryId, boardId, ...rest }) {
+        return await this.web.request({
+            method: 'GET', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/flashcards`),
+        });
+    }
+    async initializeDeck({ auth, groupId, categoryId, boardId, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/flashcards/initialize`),
+        });
+    }
+    async destroyDeck({ auth, groupId, categoryId, boardId, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/flashcards/destroy`),
+        });
+    }
+    async createCards({ auth, groupId, categoryId, boardId, body, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth, body, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/flashcards`),
+        });
+    }
+    async updateCards({ auth, groupId, categoryId, boardId, body, ...rest }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/flashcards`),
+        });
+    }
+    async deleteCards({ auth, groupId, categoryId, boardId, body, ...rest }) {
+        return await this.web.request({
+            method: 'DELETE', auth, body, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/flashcards`),
+        });
+    }
+    async overrideCards({ auth, groupId, categoryId, boardId, body, ...rest }) {
+        return await this.web.request({
+            method: 'PUT', auth, body, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/flashcards/override`),
+        });
+    }
+    async updateProgress({ auth, groupId, categoryId, boardId, body, ...rest }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/flashcards/progress`),
+        });
+    }
+    async resetProgress({ auth, groupId, categoryId, boardId, ...rest }) {
+        return await this.web.request({
+            method: 'DELETE', auth, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/flashcards/progress`),
+        });
+    }
+    async reorderCards({ auth, groupId, categoryId, boardId, body, ...rest }) {
+        return await this.web.request({
+            method: 'PUT', auth, body, ...rest,
+            endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/flashcards/reorder`),
+        });
+    }
+}

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

@@ -0,0 +1,80 @@
+import { NameInput, SingleOutput } from '../external/types';
+import { BoardsManager } from '../core/manager';
+import { WithHeaders } from '../types';
+export declare class APIGroups {
+    private web;
+    constructor(web: BoardsManager);
+    getAllSorted({ auth, ...rest }: GroupsFunctionsInput['getAllSorted']): Promise<import("..").WebResponse<GetAllSortedOutput>>;
+    getGroups({ auth, ...rest }: GroupsFunctionsInput['getGroups']): Promise<import("..").WebResponse<GetGroupsOutput>>;
+    getGroup({ auth, groupId, ...rest }: GroupsFunctionsInput['getGroup']): Promise<import("..").WebResponse<GetGroupOutput>>;
+    createGroup({ auth, body, ...rest }: GroupsFunctionsInput['createGroup']): Promise<import("..").WebResponse<string>>;
+    createCategoryInGroup({ auth, groupId, body, ...rest }: GroupsFunctionsInput['createCategoryInGroup']): Promise<import("..").WebResponse<string>>;
+    updateGroup({ auth, groupId, body, ...rest }: GroupsFunctionsInput['updateGroup']): Promise<import("..").WebResponse<string>>;
+    reorderGroups({ auth, body, ...rest }: GroupsFunctionsInput['reorderGroups']): Promise<import("..").WebResponse<string>>;
+    reorderCategoriesInGroup({ auth, groupId, body, ...rest }: GroupsFunctionsInput['reorderCategoriesInGroup']): Promise<import("..").WebResponse<string>>;
+    deleteGroup({ auth, groupId, ...rest }: GroupsFunctionsInput['deleteGroup']): Promise<import("..").WebResponse<string>>;
+}
+export type GroupsFunctionsInput = WithHeaders<{
+    'getAllSorted': {
+        auth: string;
+    };
+    'getGroups': {
+        auth: string;
+    };
+    'getGroup': {
+        auth: string;
+        groupId: string;
+    };
+    'createGroup': {
+        auth: string;
+        body: NameInput & {
+            copyPermissionsFromGroupId?: string;
+        };
+    };
+    'createCategoryInGroup': {
+        auth: string;
+        groupId: string;
+        body: NameInput & {
+            copyPermissionsFromCategoryId?: string;
+        };
+    };
+    'updateGroup': {
+        auth: string;
+        groupId: string;
+        body: NameInput;
+    };
+    'reorderGroups': {
+        auth: string;
+        body: string[];
+    };
+    'reorderCategoriesInGroup': {
+        auth: string;
+        groupId: string;
+        body: string[];
+    };
+    'deleteGroup': {
+        auth: string;
+        groupId: string;
+    };
+}>;
+export type GetGroupsOutput = (SingleOutput & {
+    categories: number;
+    isDefault: boolean;
+    sizeBytes: number;
+})[];
+export type GetGroupOutput = {
+    group: SingleOutput;
+    categories: (SingleOutput & {
+        boards: number;
+        totalSizeBytes: number;
+    })[];
+};
+export type GetAllSortedOutput = (SingleOutput & {
+    categories: (SingleOutput & {
+        boards: (SingleOutput & {
+            hasFlashcards: boolean;
+            totalSizeBytes: number;
+            scheduledForDeletion: Date | null;
+        })[];
+    })[];
+})[];