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

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;
+        })[];
+    })[];
+})[];

package/dist/src/classes/groups.js

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

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

@@ -0,0 +1,116 @@
+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, ...rest }: InvitesFunctionsInput['getUserInvites']): Promise<import("..").WebResponse<GetUserInvitesOutput>>;
+    getResourceInvites({ auth, query, ...rest }: InvitesFunctionsInput['getResourceInvites']): Promise<import("..").WebResponse<GetResourceInvitesOutput>>;
+    getInviteDetails({ auth, code, ...rest }: InvitesFunctionsInput['getInviteDetails']): Promise<import("..").WebResponse<InviteDetails>>;
+    createInvite({ auth, body, ...rest }: InvitesFunctionsInput['createInvite']): Promise<import("..").WebResponse<CreateInviteOutput>>;
+    useInvite({ auth, code, ...rest }: InvitesFunctionsInput['useInvite']): Promise<import("..").WebResponse<UseInviteOutput>>;
+    renewInvite({ auth, code, ...rest }: InvitesFunctionsInput['renewInvite']): Promise<import("..").WebResponse<RenewInviteOutput>>;
+    revokeInvite({ auth, code, ...rest }: InvitesFunctionsInput['revokeInvite']): Promise<import("..").WebResponse<string>>;
+}
+export type InvitesFunctionsInput = WithHeaders<{
+    'getUserInvites': {
+        auth: string;
+    };
+    'getResourceInvites': {
+        auth: string;
+        query: ViewInvitesQuery;
+    };
+    'getInviteDetails': {
+        auth: string;
+        code: string;
+    };
+    'createInvite': {
+        auth: string;
+        body: CreateInviteInput;
+    };
+    'useInvite': {
+        auth: string;
+        code: string;
+    };
+    'revokeInvite': {
+        auth: string;
+        code: string;
+    };
+    'renewInvite': {
+        auth: string;
+        code: string;
+    };
+}>;
+export type ViewInvitesQuery = {
+    type: ResourceType;
+    groupId?: string;
+    categoryId?: string;
+    boardId?: string;
+};
+export type CreateInviteInput = {
+    groupIds?: string[];
+    categoryIds?: string[];
+    boardIds?: string[];
+    groupRole?: GroupRole;
+    categoryRole?: CategoryRole;
+    boardRole?: BoardRole;
+    expiresIn?: number;
+    maxUses?: number;
+};
+export type CreateInviteOutput = {
+    code: string;
+    expiresAt: string;
+    maxUses: number;
+};
+export type RenewInviteOutput = CreateInviteOutput & {
+    currentUses: number;
+};
+export type GetUserInvitesOutput = {
+    invites: InviteData[];
+    canInvite: boolean;
+};
+export type GetResourceInvitesOutput = InviteData[];
+export type UseInviteOutput = {
+    granted: GrantedRoles;
+    details: {
+        groups: {
+            groupId: string;
+            name: string;
+        }[];
+        categories: {
+            categoryId: string;
+            name: string;
+            groupId: string;
+        }[];
+        boards: {
+            boardId: string;
+            name: string;
+            categoryId: string;
+        }[];
+    };
+};
+export type InviteDetails = RenewInviteOutput & {
+    invitedBy: {
+        userId: string;
+        displayName: string;
+        avatarUrl: string | null;
+    };
+};
+export type InviteData = Pick<Invite, 'code' | 'expiresAt' | 'maxUses' | 'currentUses' | 'boardRole' | 'categoryRole' | 'groupRole'> & {
+    groups: {
+        groupId: string;
+        name: string;
+    }[];
+    categories: {
+        categoryId: string;
+        name: string;
+        groupId: string;
+    }[];
+    boards: {
+        boardId: string;
+        name: string;
+        categoryId: string;
+    }[];
+};

package/dist/src/classes/invites.js

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

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

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

package/dist/src/classes/metrics.js

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

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

@@ -0,0 +1,48 @@
+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, ...rest }: PermissionsFunctionsInput['viewPermissions']): Promise<import("..").WebResponse<PermUser[]>>;
+    viewAllPermissions({ auth, userIds, ...rest }: PermissionsFunctionsInput['viewAllPermissions']): Promise<import("..").WebResponse<Record<string, PermUser>>>;
+    grantPermissions({ auth, body, ...rest }: PermissionsFunctionsInput['grantPermissions']): Promise<import("..").WebResponse<string>>;
+    revokePermissions({ auth, body, ...rest }: PermissionsFunctionsInput['revokePermissions']): Promise<import("..").WebResponse<string>>;
+}
+export type PermissionsFunctionsInput = WithHeaders<{
+    'viewPermissions': {
+        auth: string;
+        query: ViewPermissionsQuery;
+    };
+    'viewAllPermissions': {
+        auth: string;
+        userIds: string[];
+    };
+    'grantPermissions': {
+        auth: string;
+        body: GrantPermissionsInput;
+    };
+    'revokePermissions': {
+        auth: string;
+        body: RevokePermissionsInput;
+    };
+}>;
+export type ViewPermissionsQuery = {
+    type: ResourceType;
+    id: string;
+};
+export type GrantPermissionsInput = {
+    userId: string;
+    groupIds?: string[];
+    groupRole?: GroupRole;
+    categoryIds?: string[];
+    categoryRole?: CategoryRole;
+    boardIds?: string[];
+    boardRole?: BoardRole;
+};
+export type RevokePermissionsInput = {
+    userId: string;
+    resourceType: ResourceType;
+    resourceId: string;
+};

package/dist/src/classes/permissions.js

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

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

@@ -0,0 +1,61 @@
+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, ...rest }: SessionsFunctionsInput['createSession']): Promise<import("..").WebResponse<CreateSessionOutput>>;
+    getAllSessions({ auth, ...rest }: SessionsFunctionsInput['getAllSessions']): Promise<import("..").WebResponse<SessionsOutput>>;
+    deleteSession({ auth, dbId, ...rest }: SessionsFunctionsInput['deleteSession']): Promise<import("..").WebResponse<string>>;
+    deleteAllSessions({ auth, ...rest }: SessionsFunctionsInput['deleteAllSessions']): Promise<import("..").WebResponse<string>>;
+    rotateLinkedSession({ auth, body, ...rest }: SessionsFunctionsInput['rotateLinkedSession']): Promise<import("..").WebResponse<string>>;
+}
+export type SessionsFunctionsInput = WithHeaders<{
+    'createSession': {
+        auth: string;
+        body: CreateSessionInput;
+    };
+    'getAllSessions': {
+        auth: string;
+    };
+    'deleteSession': {
+        auth: string;
+        dbId: string;
+    };
+    'deleteAllSessions': {
+        auth: string;
+    };
+    'rotateLinkedSession': {
+        auth: string;
+        body: UnlinkLoginMethodInput;
+    };
+}>;
+export type CreateSessionInput = {
+    ip?: string;
+    email: string;
+    device?: Device;
+    platform: Platforms;
+    displayName: string;
+    avatarUrl?: string | null;
+    currentUserId?: string;
+    refreshProfile?: boolean;
+};
+export type CreateSessionOutput = {
+    token: string;
+    expiresAt: Date;
+};
+export type SessionsOutput = {
+    activeDbId: string;
+    sessions: {
+        location: string | null;
+        device: Device | null;
+        tokenPreview: string;
+        dbId: string;
+        expiresAt: Date;
+        createdAt: Date;
+        lastUsed: Date;
+    }[];
+};
+export type UnlinkLoginMethodInput = {
+    platform: Platforms;
+};

package/dist/src/classes/sessions.js

@@ -0,0 +1,38 @@
+// Data.
+export class APISessions {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async createSession({ auth, body, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth, body, ...rest,
+            endpoint: this.web.qp('/sessions'),
+        });
+    }
+    async getAllSessions({ auth, ...rest }) {
+        return await this.web.request({
+            method: 'GET', auth, ...rest,
+            endpoint: this.web.qp('/sessions'),
+        });
+    }
+    async deleteSession({ auth, dbId, ...rest }) {
+        return await this.web.request({
+            method: 'DELETE', auth, body: { dbId }, ...rest,
+            endpoint: this.web.qp('/sessions'),
+        });
+    }
+    async deleteAllSessions({ auth, ...rest }) {
+        return await this.web.request({
+            method: 'DELETE', auth, ...rest,
+            endpoint: this.web.qp('/sessions/all'),
+        });
+    }
+    async rotateLinkedSession({ auth, body, ...rest }) {
+        return await this.web.request({
+            method: 'POST', auth, body, ...rest,
+            endpoint: this.web.qp('/sessions/rotate'),
+        });
+    }
+}

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

@@ -0,0 +1,37 @@
+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, ...rest }: UsersFunctionsInput['getCurrentUser']): Promise<import("..").WebResponse<GetUsersOutput>>;
+    updateUser({ auth, userId, body, ...rest }: UsersFunctionsInput['updateUser']): Promise<import("..").WebResponse<string>>;
+    deleteAccount({ auth, userId, ...rest }: UsersFunctionsInput['deleteAccount']): Promise<import("..").WebResponse<void>>;
+}
+export type UsersFunctionsInput = WithHeaders<{
+    'getCurrentUser': {
+        auth: string;
+        userId?: string;
+    };
+    'updateUser': {
+        auth: string;
+        userId?: string;
+        body: UserInput;
+    };
+    'deleteAccount': {
+        auth: string;
+        userId?: string;
+    };
+    'isCurrentUserDev': {
+        auth: string;
+    };
+}>;
+export type GetUsersOutput = DBUserPartialType & {
+    isDev: boolean;
+};
+export type UserInput = {
+    mainGroupId?: string | null;
+    displayName?: string;
+    platform?: Platforms;
+};

package/dist/src/classes/users.js

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