@excali-boards/boards-api-client 1.1.45 → 1.1.47

package/dist/classes/admin.d.ts

@@ -1,14 +1,14 @@
+import { Paginated, WithHeaders } from '../types';
 import { BoardsManager } from '../core/manager';
 import { AllRooms } from '../external/types';
 import { GetUsersOutput } from './users';
-import { Paginated } from '../types';
 export declare class APIAdmin {
     private web;
     constructor(web: BoardsManager);
-    getUsers({ auth, page, limit }: AdminFunctionsInput['getUsers']): Promise<import("../types").WebResponse<Paginated<GetUsersOutput>>>;
-    getActiveRooms({ auth }: AdminFunctionsInput['getActiveRooms']): Promise<import("../types").WebResponse<AllRooms>>;
+    getUsers({ auth, page, limit, ...rest }: AdminFunctionsInput['getUsers']): Promise<import("../types").WebResponse<Paginated<GetUsersOutput>>>;
+    getActiveRooms({ auth, ...rest }: AdminFunctionsInput['getActiveRooms']): Promise<import("../types").WebResponse<AllRooms>>;
 }
-export type AdminFunctionsInput = {
+export type AdminFunctionsInput = WithHeaders<{
     'getUsers': {
         auth: string;
         page?: number;
@@ -17,4 +17,4 @@ export type AdminFunctionsInput = {
     'getActiveRooms': {
         auth: string;
     };
-};
+}>;

package/dist/classes/admin.js

@@ -8,15 +8,15 @@ class APIAdmin {
         this.web = web;
     }
     // Methods.
-    async getUsers({ auth, page, limit }) {
+    async getUsers({ auth, page, limit, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp('/admin/users', { page, limit }),
         });
     }
-    async getActiveRooms({ auth }) {
+    async getActiveRooms({ auth, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp('/admin/rooms'),
         });
     }

package/dist/classes/analytics.d.ts

@@ -1,13 +1,18 @@
 import { BoardsManager } from '../core/manager';
+import { WithHeaders } from '../types';
 export declare class APIAnalytics {
     private web;
     constructor(web: BoardsManager);
-    getUserAnalytics({ auth }: AnalyticsFunctionsInput['getUserAnalytics']): Promise<import("..").WebResponse<UserBoardActivityWithBoard[]>>;
-    getBoardAnalytics({ auth, boardId, categoryId, groupId }: AnalyticsFunctionsInput['getBoardAnalytics']): Promise<import("..").WebResponse<UserBoardActivityWithUser[]>>;
-    getCategoryAnalytics({ auth, categoryId, groupId }: AnalyticsFunctionsInput['getCategoryAnalytics']): Promise<import("..").WebResponse<UserBoardActivityWithUser[]>>;
-    getGroupAnalytics({ auth, groupId }: AnalyticsFunctionsInput['getGroupAnalytics']): Promise<import("..").WebResponse<UserBoardActivityWithUser[]>>;
+    getGlobalAnalytics({ auth, ...rest }: AnalyticsFunctionsInput['getGlobalAnalytics']): Promise<import("../types").WebResponse<UserBoardActivityWithUser[]>>;
+    getUserAnalytics({ auth, ...rest }: AnalyticsFunctionsInput['getUserAnalytics']): Promise<import("../types").WebResponse<UserBoardActivityWithBoard[]>>;
+    getBoardAnalytics({ auth, boardId, categoryId, groupId, ...rest }: AnalyticsFunctionsInput['getBoardAnalytics']): Promise<import("../types").WebResponse<UserBoardActivityWithUser[]>>;
+    getCategoryAnalytics({ auth, categoryId, groupId, ...rest }: AnalyticsFunctionsInput['getCategoryAnalytics']): Promise<import("../types").WebResponse<UserBoardActivityWithUser[]>>;
+    getGroupAnalytics({ auth, groupId, ...rest }: AnalyticsFunctionsInput['getGroupAnalytics']): Promise<import("../types").WebResponse<UserBoardActivityWithUser[]>>;
 }
-export type AnalyticsFunctionsInput = {
+export type AnalyticsFunctionsInput = WithHeaders<{
+    'getGlobalAnalytics': {
+        auth: string;
+    };
     'getUserAnalytics': {
         auth: string;
     };
@@ -26,7 +31,7 @@ export type AnalyticsFunctionsInput = {
         auth: string;
         groupId: string;
     };
-};
+}>;
 export type ActivityAnalytics = {
     totalSessions: number;
     totalActiveSeconds: number;

package/dist/classes/analytics.js

@@ -8,27 +8,33 @@ class APIAnalytics {
         this.web = web;
     }
     // Methods.
-    async getUserAnalytics({ auth }) {
+    async getGlobalAnalytics({ auth, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
+            endpoint: this.web.qp('/analytics'),
+        });
+    }
+    async getUserAnalytics({ auth, ...rest }) {
+        return await this.web.request({
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp('/analytics/user'),
         });
     }
-    async getBoardAnalytics({ auth, boardId, categoryId, groupId }) {
+    async getBoardAnalytics({ auth, boardId, categoryId, groupId, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/boards/${boardId}/analytics`),
         });
     }
-    async getCategoryAnalytics({ auth, categoryId, groupId }) {
+    async getCategoryAnalytics({ auth, categoryId, groupId, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp(`/groups/${groupId}/categories/${categoryId}/analytics`),
         });
     }
-    async getGroupAnalytics({ auth, groupId }) {
+    async getGroupAnalytics({ auth, groupId, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp(`/groups/${groupId}/analytics`),
         });
     }

package/dist/classes/boards.d.ts

@@ -1,19 +1,20 @@
 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 }: BoardsFunctionsInput['getBoards']): Promise<import("..").WebResponse<GetBoardOutput[]>>;
-    getBoard({ auth, categoryId, groupId, boardId }: BoardsFunctionsInput['getBoard']): Promise<import("..").WebResponse<GetBoardOutput>>;
-    updateBoard({ auth, categoryId, groupId, boardId, body }: BoardsFunctionsInput['updateBoard']): Promise<import("..").WebResponse<string>>;
-    scheduleBoardDeletion({ auth, categoryId, groupId, boardId }: BoardsFunctionsInput['scheduleBoardDeletion']): Promise<import("..").WebResponse<string>>;
-    forceDeleteBoard({ auth, categoryId, groupId, boardId }: BoardsFunctionsInput['scheduleBoardDeletion']): Promise<import("..").WebResponse<string>>;
-    cancelBoardDeletion({ auth, categoryId, groupId, boardId }: BoardsFunctionsInput['cancelBoardDeletion']): Promise<import("..").WebResponse<string>>;
-    getBoardRoomData({ auth, categoryId, groupId, boardId }: BoardsFunctionsInput['getRoomData']): Promise<import("..").WebResponse<AllRooms>>;
-    kickUserFromRoom({ auth, categoryId, groupId, boardId, userId }: BoardsFunctionsInput['kickUserFromRoom']): Promise<import("..").WebResponse<string>>;
+    getBoards({ auth, categoryId, groupId, ...rest }: BoardsFunctionsInput['getBoards']): Promise<import("../types").WebResponse<GetBoardOutput[]>>;
+    getBoard({ auth, categoryId, groupId, boardId, ...rest }: BoardsFunctionsInput['getBoard']): Promise<import("../types").WebResponse<GetBoardOutput>>;
+    updateBoard({ auth, categoryId, groupId, boardId, body, ...rest }: BoardsFunctionsInput['updateBoard']): Promise<import("../types").WebResponse<string>>;
+    scheduleBoardDeletion({ auth, categoryId, groupId, boardId, ...rest }: BoardsFunctionsInput['scheduleBoardDeletion']): Promise<import("../types").WebResponse<string>>;
+    forceDeleteBoard({ auth, categoryId, groupId, boardId, ...rest }: BoardsFunctionsInput['scheduleBoardDeletion']): Promise<import("../types").WebResponse<string>>;
+    cancelBoardDeletion({ auth, categoryId, groupId, boardId, ...rest }: BoardsFunctionsInput['cancelBoardDeletion']): Promise<import("../types").WebResponse<string>>;
+    getBoardRoomData({ auth, categoryId, groupId, boardId, ...rest }: BoardsFunctionsInput['getRoomData']): Promise<import("../types").WebResponse<AllRooms>>;
+    kickUserFromRoom({ auth, categoryId, groupId, boardId, userId, ...rest }: BoardsFunctionsInput['kickUserFromRoom']): Promise<import("../types").WebResponse<string>>;
 }
-export type BoardsFunctionsInput = {
+export type BoardsFunctionsInput = WithHeaders<{
     'getBoards': {
         auth: string;
         categoryId: string;
@@ -57,7 +58,7 @@ export type BoardsFunctionsInput = {
         boardId: string;
         userId: string;
     };
-};
+}>;
 export type GetBoardOutput = {
     group: SingleOutput;
     category: SingleOutput;

package/dist/classes/boards.js

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

package/dist/classes/calendar.d.ts

@@ -1,16 +1,17 @@
 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 }: CalendarFunctionsInput['getCalendar']): Promise<import("..").WebResponse<GetCalendarResponse>>;
-    getHolidays({ auth, countryCode, year }: CalendarFunctionsInput['getHolidays']): Promise<import("..").WebResponse<FormattedHoliday[]>>;
-    updateGroupCalendarCode({ auth, groupId, calCode }: CalendarFunctionsInput['updateGroupCalendarCode']): Promise<import("..").WebResponse<string>>;
-    createEvent({ auth, groupId, event }: CalendarFunctionsInput['createEvent']): Promise<import("..").WebResponse<string>>;
-    updateEvent({ auth, groupId, eventId, event }: CalendarFunctionsInput['updateEvent']): Promise<import("..").WebResponse<string>>;
-    deleteEvent({ auth, groupId, eventId }: CalendarFunctionsInput['deleteEvent']): Promise<import("..").WebResponse<string>>;
+    getCalendar({ auth, groupId, ...rest }: CalendarFunctionsInput['getCalendar']): Promise<import("../types").WebResponse<GetCalendarResponse>>;
+    getHolidays({ auth, countryCode, year, ...rest }: CalendarFunctionsInput['getHolidays']): Promise<import("../types").WebResponse<FormattedHoliday[]>>;
+    updateGroupCalendarCode({ auth, groupId, calCode, ...rest }: CalendarFunctionsInput['updateGroupCalendarCode']): Promise<import("../types").WebResponse<string>>;
+    createEvent({ auth, groupId, event, ...rest }: CalendarFunctionsInput['createEvent']): Promise<import("../types").WebResponse<string>>;
+    updateEvent({ auth, groupId, eventId, event, ...rest }: CalendarFunctionsInput['updateEvent']): Promise<import("../types").WebResponse<string>>;
+    deleteEvent({ auth, groupId, eventId, ...rest }: CalendarFunctionsInput['deleteEvent']): Promise<import("../types").WebResponse<string>>;
 }
-export type CalendarFunctionsInput = {
+export type CalendarFunctionsInput = WithHeaders<{
     'getCalendar': {
         auth: string;
         groupId: string;
@@ -41,7 +42,7 @@ export type CalendarFunctionsInput = {
         groupId: string;
         eventId: string;
     };
-};
+}>;
 export type EventObject = {
     title: string;
     start: Date;

package/dist/classes/calendar.js

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

package/dist/classes/categories.d.ts

@@ -1,17 +1,18 @@
 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 }: CategoriesFunctionsInput['getCategories']): Promise<import("..").WebResponse<GetCategoriesOutput>>;
-    getCategory({ auth, groupId, categoryId }: CategoriesFunctionsInput['getCategory']): Promise<import("..").WebResponse<GetCategoryOutput>>;
-    createBoardInCategory({ auth, groupId, categoryId, body }: CategoriesFunctionsInput['createBoardInCategory']): Promise<import("..").WebResponse<string>>;
-    updateCategory({ auth, groupId, categoryId, body }: CategoriesFunctionsInput['updateCategory']): Promise<import("..").WebResponse<string>>;
-    reorderBoardsInCategory({ auth, groupId, categoryId, body }: CategoriesFunctionsInput['reorderBoards']): Promise<import("..").WebResponse<string>>;
-    deleteCategory({ auth, groupId, categoryId }: CategoriesFunctionsInput['deleteCategory']): Promise<import("..").WebResponse<string>>;
+    getCategories({ auth, groupId, ...rest }: CategoriesFunctionsInput['getCategories']): Promise<import("../types").WebResponse<GetCategoriesOutput>>;
+    getCategory({ auth, groupId, categoryId, ...rest }: CategoriesFunctionsInput['getCategory']): Promise<import("../types").WebResponse<GetCategoryOutput>>;
+    createBoardInCategory({ auth, groupId, categoryId, body, ...rest }: CategoriesFunctionsInput['createBoardInCategory']): Promise<import("../types").WebResponse<string>>;
+    updateCategory({ auth, groupId, categoryId, body, ...rest }: CategoriesFunctionsInput['updateCategory']): Promise<import("../types").WebResponse<string>>;
+    reorderBoardsInCategory({ auth, groupId, categoryId, body, ...rest }: CategoriesFunctionsInput['reorderBoards']): Promise<import("../types").WebResponse<string>>;
+    deleteCategory({ auth, groupId, categoryId, ...rest }: CategoriesFunctionsInput['deleteCategory']): Promise<import("../types").WebResponse<string>>;
 }
-export type CategoriesFunctionsInput = {
+export type CategoriesFunctionsInput = WithHeaders<{
     'getCategories': {
         auth: string;
         groupId: string;
@@ -44,7 +45,7 @@ export type CategoriesFunctionsInput = {
         groupId: string;
         categoryId: string;
     };
-};
+}>;
 export type GetCategoriesOutput = (SingleOutput & {
     boards: number;
     group: SingleOutput;

package/dist/classes/categories.js

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

package/dist/classes/files.d.ts

@@ -1,12 +1,13 @@
 import { BoardsManager } from '../core/manager';
+import { WithHeaders } from '../types';
 export declare class APIFiles {
     private web;
     constructor(web: BoardsManager);
-    uploadBase64Files({ auth, boardId, files }: FilesFunctionsInput['uploadBase64Files']): Promise<import("..").WebResponse<FileUploadResponse>>;
-    uploadRawFiles({ auth, boardId, files }: FilesFunctionsInput['uploadRawFiles']): Promise<import("..").WebResponse<FileUploadResponse>>;
-    deleteFiles({ auth, boardId, fileIds }: FilesFunctionsInput['deleteFiles']): Promise<import("..").WebResponse<string>>;
+    uploadBase64Files({ auth, boardId, files, ...rest }: FilesFunctionsInput['uploadBase64Files']): Promise<import("../types").WebResponse<FileUploadResponse>>;
+    uploadRawFiles({ auth, boardId, files, ...rest }: FilesFunctionsInput['uploadRawFiles']): Promise<import("../types").WebResponse<FileUploadResponse>>;
+    deleteFiles({ auth, boardId, fileIds, ...rest }: FilesFunctionsInput['deleteFiles']): Promise<import("../types").WebResponse<string>>;
 }
-export type FilesFunctionsInput = {
+export type FilesFunctionsInput = WithHeaders<{
     'uploadBase64Files': {
         auth: string;
         boardId: string;
@@ -22,7 +23,7 @@ export type FilesFunctionsInput = {
         boardId: string;
         fileIds: string[];
     };
-};
+}>;
 export type Base64FileInput = {
     id: string;
     data: string;

package/dist/classes/files.js

@@ -6,27 +6,27 @@ class APIFiles {
     constructor(web) {
         this.web = web;
     }
-    async uploadBase64Files({ auth, boardId, files }) {
+    async uploadBase64Files({ auth, boardId, files, ...rest }) {
         return await this.web.request({
-            method: 'POST', auth,
+            method: 'POST', auth, ...rest,
             endpoint: `/files/${boardId}/base64`,
             body: files,
         });
     }
-    async uploadRawFiles({ auth, boardId, 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,
+            method: 'POST', auth, ...rest,
             endpoint: `/files/${boardId}/raw`,
             body: formData,
         });
     }
-    async deleteFiles({ auth, boardId, fileIds }) {
+    async deleteFiles({ auth, boardId, fileIds, ...rest }) {
         return await this.web.request({
-            method: 'DELETE', auth,
+            method: 'DELETE', auth, ...rest,
             endpoint: `/files/${boardId}/delete`,
             body: fileIds,
         });

package/dist/classes/flashcards.d.ts

@@ -1,20 +1,21 @@
 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 }: FlashcardsFunctionsInput['getDeck']): Promise<import("..").WebResponse<FlashcardDeckResponse>>;
-    initializeDeck({ auth, groupId, categoryId, boardId }: FlashcardsFunctionsInput['initializeDeck']): Promise<import("..").WebResponse<string>>;
-    destroyDeck({ auth, groupId, categoryId, boardId }: FlashcardsFunctionsInput['destroyDeck']): Promise<import("..").WebResponse<string>>;
-    createCards({ auth, groupId, categoryId, boardId, body }: FlashcardsFunctionsInput['createCards']): Promise<import("..").WebResponse<string>>;
-    updateCards({ auth, groupId, categoryId, boardId, body }: FlashcardsFunctionsInput['updateCards']): Promise<import("..").WebResponse<string>>;
-    deleteCards({ auth, groupId, categoryId, boardId, body }: FlashcardsFunctionsInput['deleteCards']): Promise<import("..").WebResponse<string>>;
-    overrideCards({ auth, groupId, categoryId, boardId, body }: FlashcardsFunctionsInput['overrideCards']): Promise<import("..").WebResponse<string>>;
-    updateProgress({ auth, groupId, categoryId, boardId, body }: FlashcardsFunctionsInput['updateProgress']): Promise<import("..").WebResponse<string>>;
-    resetProgress({ auth, groupId, categoryId, boardId }: FlashcardsFunctionsInput['resetProgress']): Promise<import("..").WebResponse<string>>;
-    reorderCards({ auth, groupId, categoryId, boardId, body }: FlashcardsFunctionsInput['reorderCards']): Promise<import("..").WebResponse<string>>;
+    getDeck({ auth, groupId, categoryId, boardId, ...rest }: FlashcardsFunctionsInput['getDeck']): Promise<import("../types").WebResponse<FlashcardDeckResponse>>;
+    initializeDeck({ auth, groupId, categoryId, boardId, ...rest }: FlashcardsFunctionsInput['initializeDeck']): Promise<import("../types").WebResponse<string>>;
+    destroyDeck({ auth, groupId, categoryId, boardId, ...rest }: FlashcardsFunctionsInput['destroyDeck']): Promise<import("../types").WebResponse<string>>;
+    createCards({ auth, groupId, categoryId, boardId, body, ...rest }: FlashcardsFunctionsInput['createCards']): Promise<import("../types").WebResponse<string>>;
+    updateCards({ auth, groupId, categoryId, boardId, body, ...rest }: FlashcardsFunctionsInput['updateCards']): Promise<import("../types").WebResponse<string>>;
+    deleteCards({ auth, groupId, categoryId, boardId, body, ...rest }: FlashcardsFunctionsInput['deleteCards']): Promise<import("../types").WebResponse<string>>;
+    overrideCards({ auth, groupId, categoryId, boardId, body, ...rest }: FlashcardsFunctionsInput['overrideCards']): Promise<import("../types").WebResponse<string>>;
+    updateProgress({ auth, groupId, categoryId, boardId, body, ...rest }: FlashcardsFunctionsInput['updateProgress']): Promise<import("../types").WebResponse<string>>;
+    resetProgress({ auth, groupId, categoryId, boardId, ...rest }: FlashcardsFunctionsInput['resetProgress']): Promise<import("../types").WebResponse<string>>;
+    reorderCards({ auth, groupId, categoryId, boardId, body, ...rest }: FlashcardsFunctionsInput['reorderCards']): Promise<import("../types").WebResponse<string>>;
 }
-export type FlashcardsFunctionsInput = {
+export type FlashcardsFunctionsInput = WithHeaders<{
     getDeck: {
         auth: string;
         groupId: string;
@@ -81,7 +82,7 @@ export type FlashcardsFunctionsInput = {
         boardId: string;
         body: string[];
     };
-};
+}>;
 export type CardInput = {
     front: string;
     back: string;

package/dist/classes/flashcards.js

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

package/dist/classes/groups.d.ts

@@ -1,19 +1,20 @@
 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 }: GroupsFunctionsInput['getAllSorted']): Promise<import("..").WebResponse<GetAllSortedOutput>>;
-    getGroups({ auth }: GroupsFunctionsInput['getGroups']): Promise<import("..").WebResponse<GetGroupsOutput>>;
-    getGroup({ auth, groupId }: GroupsFunctionsInput['getGroup']): Promise<import("..").WebResponse<GetGroupOutput>>;
-    createGroup({ auth, body }: GroupsFunctionsInput['createGroup']): Promise<import("..").WebResponse<string>>;
-    createCategoryInGroup({ auth, groupId, body }: GroupsFunctionsInput['createCategoryInGroup']): Promise<import("..").WebResponse<string>>;
-    updateGroup({ auth, groupId, body }: GroupsFunctionsInput['updateGroup']): Promise<import("..").WebResponse<string>>;
-    reorderGroups({ auth, body }: GroupsFunctionsInput['reorderGroups']): Promise<import("..").WebResponse<string>>;
-    reorderCategoriesInGroup({ auth, groupId, body }: GroupsFunctionsInput['reorderCategoriesInGroup']): Promise<import("..").WebResponse<string>>;
-    deleteGroup({ auth, groupId }: GroupsFunctionsInput['deleteGroup']): Promise<import("..").WebResponse<string>>;
+    getAllSorted({ auth, ...rest }: GroupsFunctionsInput['getAllSorted']): Promise<import("../types").WebResponse<GetAllSortedOutput>>;
+    getGroups({ auth, ...rest }: GroupsFunctionsInput['getGroups']): Promise<import("../types").WebResponse<GetGroupsOutput>>;
+    getGroup({ auth, groupId, ...rest }: GroupsFunctionsInput['getGroup']): Promise<import("../types").WebResponse<GetGroupOutput>>;
+    createGroup({ auth, body, ...rest }: GroupsFunctionsInput['createGroup']): Promise<import("../types").WebResponse<string>>;
+    createCategoryInGroup({ auth, groupId, body, ...rest }: GroupsFunctionsInput['createCategoryInGroup']): Promise<import("../types").WebResponse<string>>;
+    updateGroup({ auth, groupId, body, ...rest }: GroupsFunctionsInput['updateGroup']): Promise<import("../types").WebResponse<string>>;
+    reorderGroups({ auth, body, ...rest }: GroupsFunctionsInput['reorderGroups']): Promise<import("../types").WebResponse<string>>;
+    reorderCategoriesInGroup({ auth, groupId, body, ...rest }: GroupsFunctionsInput['reorderCategoriesInGroup']): Promise<import("../types").WebResponse<string>>;
+    deleteGroup({ auth, groupId, ...rest }: GroupsFunctionsInput['deleteGroup']): Promise<import("../types").WebResponse<string>>;
 }
-export type GroupsFunctionsInput = {
+export type GroupsFunctionsInput = WithHeaders<{
     'getAllSorted': {
         auth: string;
     };
@@ -51,7 +52,7 @@ export type GroupsFunctionsInput = {
         auth: string;
         groupId: string;
     };
-};
+}>;
 export type GetGroupsOutput = (SingleOutput & {
     categories: number;
     isDefault: boolean;

package/dist/classes/groups.js

@@ -8,57 +8,57 @@ class APIGroups {
         this.web = web;
     }
     // Methods.
-    async getAllSorted({ auth }) {
+    async getAllSorted({ auth, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp('/all'),
         });
     }
-    async getGroups({ auth }) {
+    async getGroups({ auth, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp('/groups'),
         });
     }
-    async getGroup({ auth, groupId }) {
+    async getGroup({ auth, groupId, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp(`/groups/${groupId}`),
         });
     }
-    async createGroup({ auth, body }) {
+    async createGroup({ auth, body, ...rest }) {
         return await this.web.request({
-            method: 'POST', auth, body,
+            method: 'POST', auth, body, ...rest,
             endpoint: this.web.qp('/groups'),
         });
     }
-    async createCategoryInGroup({ auth, groupId, body }) {
+    async createCategoryInGroup({ auth, groupId, body, ...rest }) {
         return await this.web.request({
-            method: 'POST', auth, body,
+            method: 'POST', auth, body, ...rest,
             endpoint: this.web.qp(`/groups/${groupId}/categories`),
         });
     }
-    async updateGroup({ auth, groupId, body }) {
+    async updateGroup({ auth, groupId, body, ...rest }) {
         return await this.web.request({
-            method: 'PATCH', auth, body,
+            method: 'PATCH', auth, body, ...rest,
             endpoint: this.web.qp(`/groups/${groupId}`),
         });
     }
-    async reorderGroups({ auth, body }) {
+    async reorderGroups({ auth, body, ...rest }) {
         return await this.web.request({
-            method: 'PUT', auth, body,
+            method: 'PUT', auth, body, ...rest,
             endpoint: this.web.qp('/groups'),
         });
     }
-    async reorderCategoriesInGroup({ auth, groupId, body }) {
+    async reorderCategoriesInGroup({ auth, groupId, body, ...rest }) {
         return await this.web.request({
-            method: 'PUT', auth, body,
+            method: 'PUT', auth, body, ...rest,
             endpoint: this.web.qp(`/groups/${groupId}/categories`),
         });
     }
-    async deleteGroup({ auth, groupId }) {
+    async deleteGroup({ auth, groupId, ...rest }) {
         return await this.web.request({
-            method: 'DELETE', auth,
+            method: 'DELETE', auth, ...rest,
             endpoint: this.web.qp(`/groups/${groupId}`),
         });
     }

package/dist/classes/invites.d.ts

@@ -2,18 +2,19 @@ import { BoardRole, CategoryRole, GroupRole } from '../external/vars';
 import { GrantedRoles, ResourceType } from '../external/types';
 import { Invite } from '../../prisma/generated';
 import { BoardsManager } from '../core/manager';
+import { WithHeaders } from '../types';
 export declare class APIInvites {
     private web;
     constructor(web: BoardsManager);
-    getUserInvites({ auth }: InvitesFunctionsInput['getUserInvites']): Promise<import("..").WebResponse<GetUserInvitesOutput>>;
-    getResourceInvites({ auth, query }: InvitesFunctionsInput['getResourceInvites']): Promise<import("..").WebResponse<GetResourceInvitesOutput>>;
-    getInviteDetails({ auth, code }: InvitesFunctionsInput['getInviteDetails']): Promise<import("..").WebResponse<InviteDetails>>;
-    createInvite({ auth, body }: InvitesFunctionsInput['createInvite']): Promise<import("..").WebResponse<CreateInviteOutput>>;
-    useInvite({ auth, code }: InvitesFunctionsInput['useInvite']): Promise<import("..").WebResponse<UseInviteOutput>>;
-    renewInvite({ auth, code }: InvitesFunctionsInput['renewInvite']): Promise<import("..").WebResponse<RenewInviteOutput>>;
-    revokeInvite({ auth, code }: InvitesFunctionsInput['revokeInvite']): Promise<import("..").WebResponse<string>>;
+    getUserInvites({ auth, ...rest }: InvitesFunctionsInput['getUserInvites']): Promise<import("../types").WebResponse<GetUserInvitesOutput>>;
+    getResourceInvites({ auth, query, ...rest }: InvitesFunctionsInput['getResourceInvites']): Promise<import("../types").WebResponse<GetResourceInvitesOutput>>;
+    getInviteDetails({ auth, code, ...rest }: InvitesFunctionsInput['getInviteDetails']): Promise<import("../types").WebResponse<InviteDetails>>;
+    createInvite({ auth, body, ...rest }: InvitesFunctionsInput['createInvite']): Promise<import("../types").WebResponse<CreateInviteOutput>>;
+    useInvite({ auth, code, ...rest }: InvitesFunctionsInput['useInvite']): Promise<import("../types").WebResponse<UseInviteOutput>>;
+    renewInvite({ auth, code, ...rest }: InvitesFunctionsInput['renewInvite']): Promise<import("../types").WebResponse<RenewInviteOutput>>;
+    revokeInvite({ auth, code, ...rest }: InvitesFunctionsInput['revokeInvite']): Promise<import("../types").WebResponse<string>>;
 }
-export type InvitesFunctionsInput = {
+export type InvitesFunctionsInput = WithHeaders<{
     'getUserInvites': {
         auth: string;
     };
@@ -41,7 +42,7 @@ export type InvitesFunctionsInput = {
         auth: string;
         code: string;
     };
-};
+}>;
 export type ViewInvitesQuery = {
     type: ResourceType;
     groupId?: string;

package/dist/classes/invites.js

@@ -8,45 +8,45 @@ class APIInvites {
         this.web = web;
     }
     // Methods.
-    async getUserInvites({ auth }) {
+    async getUserInvites({ auth, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp('/invites'),
         });
     }
-    async getResourceInvites({ auth, query }) {
+    async getResourceInvites({ auth, query, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp('/resources/invites', query),
         });
     }
-    async getInviteDetails({ auth, code }) {
+    async getInviteDetails({ auth, code, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp(`/invites/${code}`),
         });
     }
-    async createInvite({ auth, body }) {
+    async createInvite({ auth, body, ...rest }) {
         return await this.web.request({
-            method: 'POST', auth, body,
+            method: 'POST', auth, body, ...rest,
             endpoint: this.web.qp('/invites'),
         });
     }
-    async useInvite({ auth, code }) {
+    async useInvite({ auth, code, ...rest }) {
         return await this.web.request({
-            method: 'POST', auth,
+            method: 'POST', auth, ...rest,
             endpoint: this.web.qp(`/invites/${code}`),
         });
     }
-    async renewInvite({ auth, code }) {
+    async renewInvite({ auth, code, ...rest }) {
         return await this.web.request({
-            method: 'PATCH', auth,
+            method: 'PATCH', auth, ...rest,
             endpoint: this.web.qp(`/invites/${code}`),
         });
     }
-    async revokeInvite({ auth, code }) {
+    async revokeInvite({ auth, code, ...rest }) {
         return await this.web.request({
-            method: 'DELETE', auth,
+            method: 'DELETE', auth, ...rest,
             endpoint: this.web.qp(`/invites/${code}`),
         });
     }

package/dist/classes/metrics.d.ts

@@ -1,21 +1,23 @@
 import { BoardsManager } from '../core/manager';
+import { WithHeaders } from '../types';
 export declare class APIMetrics {
     private web;
     constructor(web: BoardsManager);
-    getMetrics({ auth }: MetricsFunctionsInput['getMetrics']): Promise<import("..").WebResponse<string>>;
-    getStatus({ auth }: MetricsFunctionsInput['getStatus']): Promise<import("..").WebResponse<SystemStatus>>;
+    getMetrics({ auth, ...rest }: MetricsFunctionsInput['getMetrics']): Promise<import("../types").WebResponse<string>>;
+    getStatus({ auth, ...rest }: MetricsFunctionsInput['getStatus']): Promise<import("../types").WebResponse<SystemStatus>>;
 }
-export type MetricsFunctionsInput = {
+export type MetricsFunctionsInput = WithHeaders<{
     'getMetrics': {
         auth: string;
     };
     'getStatus': {
         auth: string;
     };
-};
+}>;
 export type SystemStatus = {
     cpuUsage: number;
-    memoryUsage: string;
+    memoryUsageMb: number;
+    uptimeSeconds: number;
     activeRooms: number;
     socketConnections: number;
     queuedFiles: number;
@@ -24,4 +26,6 @@ export type SystemStatus = {
     totalBoards: number;
     totalCategories: number;
     totalGroups: number;
+    totalFiles: number;
+    storageSizeMb: number;
 };

package/dist/classes/metrics.js

@@ -8,15 +8,15 @@ class APIMetrics {
         this.web = web;
     }
     // Methods.
-    async getMetrics({ auth }) {
+    async getMetrics({ auth, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp('/metrics'),
         });
     }
-    async getStatus({ auth }) {
+    async getStatus({ auth, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp('/metrics/status'),
         });
     }

package/dist/classes/permissions.d.ts

@@ -1,15 +1,16 @@
 import { BoardRole, CategoryRole, GroupRole } from '../external/vars';
 import { PermUser, ResourceType } from '../external/types';
 import { BoardsManager } from '../core/manager';
+import { WithHeaders } from '../types';
 export declare class APIPermissions {
     private web;
     constructor(web: BoardsManager);
-    viewPermissions({ auth, query }: PermissionsFunctionsInput['viewPermissions']): Promise<import("..").WebResponse<PermUser[]>>;
-    viewAllPermissions({ auth, userIds }: PermissionsFunctionsInput['viewAllPermissions']): Promise<import("..").WebResponse<Record<string, PermUser>>>;
-    grantPermissions({ auth, body }: PermissionsFunctionsInput['grantPermissions']): Promise<import("..").WebResponse<string>>;
-    revokePermissions({ auth, body }: PermissionsFunctionsInput['revokePermissions']): Promise<import("..").WebResponse<string>>;
+    viewPermissions({ auth, query, ...rest }: PermissionsFunctionsInput['viewPermissions']): Promise<import("../types").WebResponse<PermUser[]>>;
+    viewAllPermissions({ auth, userIds, ...rest }: PermissionsFunctionsInput['viewAllPermissions']): Promise<import("../types").WebResponse<Record<string, PermUser>>>;
+    grantPermissions({ auth, body, ...rest }: PermissionsFunctionsInput['grantPermissions']): Promise<import("../types").WebResponse<string>>;
+    revokePermissions({ auth, body, ...rest }: PermissionsFunctionsInput['revokePermissions']): Promise<import("../types").WebResponse<string>>;
 }
-export type PermissionsFunctionsInput = {
+export type PermissionsFunctionsInput = WithHeaders<{
     'viewPermissions': {
         auth: string;
         query: ViewPermissionsQuery;
@@ -26,7 +27,7 @@ export type PermissionsFunctionsInput = {
         auth: string;
         body: RevokePermissionsInput;
     };
-};
+}>;
 export type ViewPermissionsQuery = {
     type: ResourceType;
     id: string;

package/dist/classes/permissions.js

@@ -8,27 +8,27 @@ class APIPermissions {
         this.web = web;
     }
     // Methods.
-    async viewPermissions({ auth, query }) {
+    async viewPermissions({ auth, query, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp('/permissions/view', query),
         });
     }
-    async viewAllPermissions({ auth, userIds }) {
+    async viewAllPermissions({ auth, userIds, ...rest }) {
         return await this.web.request({
-            method: 'POST', auth, body: { userIds },
+            method: 'POST', auth, body: { userIds }, ...rest,
             endpoint: this.web.qp('/permissions/view-all'),
         });
     }
-    async grantPermissions({ auth, body }) {
+    async grantPermissions({ auth, body, ...rest }) {
         return await this.web.request({
-            method: 'POST', auth, body,
+            method: 'POST', auth, body, ...rest,
             endpoint: this.web.qp('/permissions/grant'),
         });
     }
-    async revokePermissions({ auth, body }) {
+    async revokePermissions({ auth, body, ...rest }) {
         return await this.web.request({
-            method: 'POST', auth, body,
+            method: 'POST', auth, body, ...rest,
             endpoint: this.web.qp('/permissions/revoke'),
         });
     }

package/dist/classes/sessions.d.ts

@@ -1,14 +1,15 @@
 import { Device, Platforms } from '../../prisma/generated/default';
 import { BoardsManager } from '../core/manager';
+import { WithHeaders } from '../types';
 export declare class APISessions {
     private web;
     constructor(web: BoardsManager);
-    createSession({ auth, body }: SessionsFunctionsInput['createSession']): Promise<import("..").WebResponse<CreateSessionOutput>>;
-    getAllSessions({ auth }: SessionsFunctionsInput['getAllSessions']): Promise<import("..").WebResponse<SessionsOutput>>;
-    deleteSession({ auth, dbId }: SessionsFunctionsInput['deleteSession']): Promise<import("..").WebResponse<string>>;
-    deleteAllSessions({ auth }: SessionsFunctionsInput['deleteAllSessions']): Promise<import("..").WebResponse<string>>;
+    createSession({ auth, body, ...rest }: SessionsFunctionsInput['createSession']): Promise<import("../types").WebResponse<CreateSessionOutput>>;
+    getAllSessions({ auth, ...rest }: SessionsFunctionsInput['getAllSessions']): Promise<import("../types").WebResponse<SessionsOutput>>;
+    deleteSession({ auth, dbId, ...rest }: SessionsFunctionsInput['deleteSession']): Promise<import("../types").WebResponse<string>>;
+    deleteAllSessions({ auth, ...rest }: SessionsFunctionsInput['deleteAllSessions']): Promise<import("../types").WebResponse<string>>;
 }
-export type SessionsFunctionsInput = {
+export type SessionsFunctionsInput = WithHeaders<{
     'createSession': {
         auth: string;
         body: CreateSessionInput;
@@ -23,7 +24,7 @@ export type SessionsFunctionsInput = {
     'deleteAllSessions': {
         auth: string;
     };
-};
+}>;
 export type CreateSessionInput = {
     ip?: string;
     email: string;

package/dist/classes/sessions.js

@@ -8,27 +8,27 @@ class APISessions {
         this.web = web;
     }
     // Methods.
-    async createSession({ auth, body }) {
+    async createSession({ auth, body, ...rest }) {
         return await this.web.request({
-            method: 'POST', auth, body,
+            method: 'POST', auth, body, ...rest,
             endpoint: this.web.qp('/sessions'),
         });
     }
-    async getAllSessions({ auth }) {
+    async getAllSessions({ auth, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp('/sessions'),
         });
     }
-    async deleteSession({ auth, dbId }) {
+    async deleteSession({ auth, dbId, ...rest }) {
         return await this.web.request({
-            method: 'DELETE', auth, body: { dbId },
+            method: 'DELETE', auth, body: { dbId }, ...rest,
             endpoint: this.web.qp('/sessions'),
         });
     }
-    async deleteAllSessions({ auth }) {
+    async deleteAllSessions({ auth, ...rest }) {
         return await this.web.request({
-            method: 'DELETE', auth,
+            method: 'DELETE', auth, ...rest,
             endpoint: this.web.qp('/sessions/all'),
         });
     }

package/dist/classes/users.d.ts

@@ -1,14 +1,15 @@
 import { Platforms } from '../../prisma/generated/default';
 import { DBUserPartialType } from '../external/vars';
 import { BoardsManager } from '../core/manager';
+import { WithHeaders } from '../types';
 export declare class APIUsers {
     private web;
     constructor(web: BoardsManager);
-    getUser({ auth, userId }: UsersFunctionsInput['getCurrentUser']): Promise<import("..").WebResponse<GetUsersOutput>>;
-    updateUser({ auth, userId, body }: UsersFunctionsInput['updateUser']): Promise<import("..").WebResponse<string>>;
-    deleteAccount({ auth, userId }: UsersFunctionsInput['deleteAccount']): Promise<import("..").WebResponse<void>>;
+    getUser({ auth, userId, ...rest }: UsersFunctionsInput['getCurrentUser']): Promise<import("../types").WebResponse<GetUsersOutput>>;
+    updateUser({ auth, userId, body, ...rest }: UsersFunctionsInput['updateUser']): Promise<import("../types").WebResponse<string>>;
+    deleteAccount({ auth, userId, ...rest }: UsersFunctionsInput['deleteAccount']): Promise<import("../types").WebResponse<void>>;
 }
-export type UsersFunctionsInput = {
+export type UsersFunctionsInput = WithHeaders<{
     'getCurrentUser': {
         auth: string;
         userId?: string;
@@ -25,7 +26,7 @@ export type UsersFunctionsInput = {
     'isCurrentUserDev': {
         auth: string;
     };
-};
+}>;
 export type GetUsersOutput = DBUserPartialType & {
     isDev: boolean;
 };

package/dist/classes/users.js

@@ -8,21 +8,21 @@ class APIUsers {
         this.web = web;
     }
     // Methods.
-    async getUser({ auth, userId }) {
+    async getUser({ auth, userId, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp('/users' + (userId ? `/${userId}` : '')),
         });
     }
-    async updateUser({ auth, userId, body }) {
+    async updateUser({ auth, userId, body, ...rest }) {
         return await this.web.request({
-            method: 'PATCH', auth, body,
+            method: 'PATCH', auth, body, ...rest,
             endpoint: this.web.qp('/users' + (userId ? `/${userId}` : '')),
         });
     }
-    async deleteAccount({ auth, userId }) {
+    async deleteAccount({ auth, userId, ...rest }) {
         return await this.web.request({
-            method: 'DELETE', auth,
+            method: 'DELETE', auth, ...rest,
             endpoint: this.web.qp('/users' + (userId ? `/${userId}` : '')),
         });
     }

package/dist/classes/utils.d.ts

@@ -1,15 +1,16 @@
 import { BoardsManager } from '../core/manager';
+import { WithHeaders } from '../types';
 export declare class APIUtils {
     private web;
     constructor(web: BoardsManager);
-    unfurlUrl({ auth, url }: UtilsFunctionsInput['unfurlUrl']): Promise<import("..").WebResponse<Partial<UnfurlOutput>>>;
+    unfurlUrl({ auth, url, ...rest }: UtilsFunctionsInput['unfurlUrl']): Promise<import("../types").WebResponse<Partial<UnfurlOutput>>>;
 }
-export type UtilsFunctionsInput = {
+export type UtilsFunctionsInput = WithHeaders<{
     'unfurlUrl': {
         auth: string;
         url: string;
     };
-};
+}>;
 export type UnfurlOutput = {
     title: string;
     description: string;

package/dist/classes/utils.js

@@ -8,9 +8,9 @@ class APIUtils {
         this.web = web;
     }
     // Methods.
-    async unfurlUrl({ auth, url }) {
+    async unfurlUrl({ auth, url, ...rest }) {
         return await this.web.request({
-            method: 'GET', auth,
+            method: 'GET', auth, ...rest,
             endpoint: this.web.qp('/utils/unfurl', {
                 url,
             }),

package/dist/types.d.ts

@@ -15,6 +15,11 @@ export type Paginated<T> = {
         hasMore: boolean;
     };
 };
+export type WithHeaders<T> = {
+    [P in keyof T]: T[P] & {
+        headers?: Record<string, string>;
+    };
+};
 export type PaginatedWebResponse<T, S extends StatusWebCode = StatusWebCode> = WebResponse<Paginated<T>, S>;
 export type SuccessWithId<T extends string> = {
     [x in T]: string;

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "1.1.45",
+	"version": "1.1.47",
 	"name": "@excali-boards/boards-api-client",
 	"description": "A simple API client for the Boards API.",
 	"repository": "https://github.com/Excali-Boards/boards-api-client",