fantsec-docmost-cli 2.2.0

package/build/client.js

@@ -0,0 +1,715 @@
+import { createReadStream, accessSync, constants as fsConstants } from "fs";
+import FormData from "form-data";
+import axios from "axios";
+import { filterWorkspace, filterSpace, filterGroup, filterPage, filterSearchResult, filterHistoryEntry, filterHistoryDetail, filterMember, filterInvite, filterUser, filterComment, filterShare, } from "./lib/filters.js";
+import { convertProseMirrorToMarkdown } from "./lib/markdown-converter.js";
+import { updatePageContentRealtime } from "./lib/collaboration.js";
+import { getCollabToken, performLogin } from "./lib/auth-utils.js";
+import { markdownToProseMirrorJson, } from "./lib/page-mentions.js";
+function ensureFileReadable(filePath) {
+    try {
+        accessSync(filePath, fsConstants.R_OK);
+    }
+    catch (err) {
+        const code = err.code ?? "UNKNOWN";
+        throw new Error(`File not found or not readable: ${filePath} (${code})`, { cause: err });
+    }
+}
+function normalizeMentionLabel(value) {
+    return value.trim().replace(/\s+/g, " ").toLocaleLowerCase();
+}
+export class DocmostClient {
+    client;
+    baseURL;
+    auth;
+    token;
+    constructor(baseURL, auth = {}) {
+        this.baseURL = baseURL.replace(/\/+$/, "");
+        this.auth = auth;
+        this.token = auth.token ?? null;
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        if (this.token) {
+            this.client.defaults.headers.common["Authorization"] =
+                `Bearer ${this.token}`;
+        }
+    }
+    async login() {
+        if (this.token) {
+            return;
+        }
+        if (!this.auth.email || !this.auth.password) {
+            throw new Error("Missing credentials. Provide token or email/password.");
+        }
+        this.token = await performLogin(this.baseURL, this.auth.email, this.auth.password);
+        this.client.defaults.headers.common["Authorization"] =
+            `Bearer ${this.token}`;
+    }
+    async ensureAuthenticated() {
+        if (!this.token) {
+            await this.login();
+        }
+    }
+    async paginateAll(endpoint, basePayload = {}, limit = 100, maxItems = Infinity) {
+        await this.ensureAuthenticated();
+        const clampedLimit = Math.max(1, Math.min(100, limit));
+        let page = 1;
+        let cursor = null;
+        let allItems = [];
+        let hasNextPage = true;
+        const seenRequests = new Set();
+        while (hasNextPage && allItems.length < maxItems) {
+            const usingCursor = cursor !== null;
+            const requestKey = usingCursor ? `cursor:${cursor}` : `page:${page}`;
+            if (seenRequests.has(requestKey)) {
+                throw new Error(`Pagination loop detected for ${endpoint}: repeated ${requestKey}`);
+            }
+            seenRequests.add(requestKey);
+            const requestPayload = {
+                ...basePayload,
+                limit: clampedLimit,
+                ...(usingCursor ? { cursor } : { page }),
+            };
+            const response = await this.client.post(endpoint, requestPayload);
+            const data = response.data;
+            const inner = data.data ?? data;
+            const items = inner.items;
+            if (!Array.isArray(items)) {
+                throw new Error(`Unexpected API response from ${endpoint}: missing items array`);
+            }
+            const meta = inner.meta;
+            if (!meta && items.length === clampedLimit) {
+                process.stderr.write(`Warning: API response from ${endpoint} missing pagination meta; results may be incomplete.\n`);
+            }
+            allItems = allItems.concat(items);
+            const nextCursor = typeof meta?.nextCursor === "string" && meta.nextCursor.length > 0
+                ? meta.nextCursor
+                : null;
+            const usesCursorPagination = usingCursor || nextCursor !== null || typeof meta?.prevCursor === "string";
+            if (usesCursorPagination) {
+                hasNextPage = Boolean(meta?.hasNextPage && nextCursor);
+                cursor = hasNextPage ? nextCursor : null;
+            }
+            else {
+                hasNextPage = meta?.hasNextPage ?? false;
+                page++;
+            }
+        }
+        const finalItems = maxItems < Infinity ? allItems.slice(0, maxItems) : allItems;
+        const truncated = finalItems.length < allItems.length;
+        return { items: finalItems, hasMore: truncated || hasNextPage };
+    }
+    async getWorkspace() {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/workspace/info", {});
+        return {
+            data: filterWorkspace(response.data.data),
+            success: response.data.success,
+        };
+    }
+    async getSpaces() {
+        const result = await this.paginateAll("/spaces", {});
+        return { items: result.items.map((space) => filterSpace(space)), hasMore: result.hasMore };
+    }
+    async getGroups() {
+        const result = await this.paginateAll("/groups", {});
+        return { items: result.items.map((group) => filterGroup(group)), hasMore: result.hasMore };
+    }
+    async listPages(spaceId) {
+        const payload = spaceId ? { spaceId } : {};
+        const result = await this.paginateAll("/pages/recent", payload);
+        return { items: result.items.map((page) => filterPage(page)), hasMore: result.hasMore };
+    }
+    async listSidebarPages(spaceId, pageId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/pages/sidebar-pages", {
+            spaceId,
+            pageId,
+            page: 1,
+        });
+        const items = response.data?.data?.items;
+        if (items !== undefined && !Array.isArray(items)) {
+            throw new Error("Unexpected API response from /pages/sidebar-pages: items is not an array");
+        }
+        return items ?? [];
+    }
+    async getPage(pageId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/pages/info", { pageId });
+        const resultData = response.data.data;
+        let content = resultData.content
+            ? convertProseMirrorToMarkdown(resultData.content)
+            : "";
+        let subpages = [];
+        try {
+            subpages = await this.listSidebarPages(resultData.spaceId, pageId);
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && (error.response?.status === 401 || error.response?.status === 403)) {
+                throw error;
+            }
+            const msg = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`Warning: failed to fetch subpages: ${msg}\n`);
+        }
+        if (content && content.includes("{{SUBPAGES}}")) {
+            if (subpages.length > 0) {
+                const list = subpages
+                    .map((p) => `- [${p.title}](page:${p.id})`)
+                    .join("\n");
+                content = content.replaceAll("{{SUBPAGES}}", `### Subpages\n${list}`);
+            }
+            else {
+                content = content.replaceAll("{{SUBPAGES}}", "");
+            }
+        }
+        return {
+            data: filterPage(resultData, content, subpages),
+            success: response.data.success,
+        };
+    }
+    async createPage(spaceId, title, icon, parentPageId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/pages/create", {
+            spaceId,
+            ...(title !== undefined && { title }),
+            ...(icon !== undefined && { icon }),
+            ...(parentPageId !== undefined && { parentPageId }),
+        });
+        return response.data.data ?? response.data;
+    }
+    async getPageTree(spaceId, pageId) {
+        await this.ensureAuthenticated();
+        if (!spaceId && !pageId)
+            throw new Error("At least one of spaceId or pageId is required");
+        const payload = {};
+        if (spaceId)
+            payload.spaceId = spaceId;
+        if (pageId)
+            payload.pageId = pageId;
+        const response = await this.client.post("/pages/sidebar-pages", { ...payload, page: 1 });
+        const items = response.data?.data?.items;
+        if (!Array.isArray(items)) {
+            throw new Error("Unexpected page tree response structure from API.");
+        }
+        return items;
+    }
+    async movePageToSpace(pageId, spaceId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/pages/move-to-space", { pageId, spaceId });
+        return response.data;
+    }
+    async exportPage(pageId, format, includeChildren, includeAttachments) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/pages/export", {
+            pageId, format,
+            ...(includeChildren !== undefined && { includeChildren }),
+            ...(includeAttachments !== undefined && { includeAttachments }),
+        }, { responseType: "arraybuffer" });
+        return response.data;
+    }
+    async importPage(filePath, spaceId) {
+        await this.ensureAuthenticated();
+        ensureFileReadable(filePath);
+        const form = new FormData();
+        form.append("spaceId", spaceId);
+        form.append("file", createReadStream(filePath));
+        const response = await axios.post(`${this.baseURL}/pages/import`, form, {
+            headers: { ...form.getHeaders(), Authorization: `Bearer ${this.token}` },
+        });
+        return response.data;
+    }
+    async importZip(filePath, spaceId, source) {
+        await this.ensureAuthenticated();
+        ensureFileReadable(filePath);
+        const form = new FormData();
+        form.append("spaceId", spaceId);
+        form.append("source", source);
+        form.append("file", createReadStream(filePath));
+        const response = await axios.post(`${this.baseURL}/pages/import-zip`, form, {
+            headers: { ...form.getHeaders(), Authorization: `Bearer ${this.token}` },
+        });
+        return response.data;
+    }
+    async updatePage(pageId, content, title, icon) {
+        await this.ensureAuthenticated();
+        const metadata = { pageId };
+        if (title !== undefined)
+            metadata.title = title;
+        if (icon !== undefined)
+            metadata.icon = icon;
+        if (Object.keys(metadata).length > 1) {
+            await this.client.post("/pages/update", metadata);
+        }
+        if (content !== undefined) {
+            if (!this.token) {
+                throw new Error("Authentication token is required for content updates");
+            }
+            let collabToken = "";
+            try {
+                collabToken = await getCollabToken(this.baseURL, this.token);
+            }
+            catch (error) {
+                if (axios.isAxiosError(error))
+                    throw error;
+                const cause = error instanceof Error ? error : undefined;
+                throw new Error(`Failed to get collaboration token: ${cause?.message ?? String(error)}`, { cause });
+            }
+            try {
+                const prosemirrorJson = await this.buildPageContentJson(pageId, content);
+                await updatePageContentRealtime(pageId, prosemirrorJson, collabToken, this.baseURL);
+            }
+            catch (error) {
+                if (axios.isAxiosError(error))
+                    throw error;
+                const cause = error instanceof Error ? error : undefined;
+                throw new Error(`Failed to update page content: ${cause?.message ?? String(error)}`, { cause });
+            }
+        }
+        return {
+            success: true,
+            modified: true,
+            message: "Page updated successfully.",
+            pageId,
+        };
+    }
+    async buildPageContentJson(pageId, content) {
+        const pageResponse = await this.client.post("/pages/info", { pageId });
+        const page = pageResponse.data?.data ?? pageResponse.data;
+        const spaceId = typeof page?.spaceId === "string" ? page.spaceId : undefined;
+        const currentUser = await this.getCurrentUser();
+        const mentionCache = new Map();
+        try {
+            return await markdownToProseMirrorJson(content, {
+                creatorId: currentUser.id,
+                resolvePageMention: async (label) => {
+                    const cacheKey = normalizeMentionLabel(label);
+                    if (mentionCache.has(cacheKey)) {
+                        return mentionCache.get(cacheKey) ?? null;
+                    }
+                    const resolved = await this.resolvePageMention(label, spaceId);
+                    mentionCache.set(cacheKey, resolved);
+                    return resolved;
+                },
+            });
+        }
+        catch (error) {
+            const cause = error instanceof Error ? error : undefined;
+            throw new Error(`Failed to convert markdown to ProseMirror JSON: ${cause?.message ?? String(error)}`, { cause });
+        }
+    }
+    async resolvePageMention(label, preferredSpaceId) {
+        const normalizedLabel = normalizeMentionLabel(label);
+        const selectSingleMatch = (pages, scope) => {
+            const matches = pages.filter((page) => normalizeMentionLabel(page.title || "") === normalizedLabel);
+            if (matches.length === 1) {
+                const match = matches[0];
+                return { id: match.id, title: match.title, slugId: match.slugId };
+            }
+            if (matches.length > 1) {
+                process.stderr.write(`Warning: mention @${label} is ambiguous in ${scope}; keeping plain text.\n`);
+            }
+            return null;
+        };
+        if (preferredSpaceId) {
+            const scoped = await this.searchSuggest(label, preferredSpaceId, {
+                includePages: true,
+                includeGroups: false,
+                includeUsers: false,
+                limit: 20,
+            });
+            const scopedPages = Array.isArray(scoped?.pages)
+                ? scoped.pages
+                : [];
+            const scopedMatch = selectSingleMatch(scopedPages, `space ${preferredSpaceId}`);
+            if (scopedMatch) {
+                return scopedMatch;
+            }
+        }
+        const workspaceWide = await this.searchSuggest(label, undefined, {
+            includePages: true,
+            includeGroups: false,
+            includeUsers: false,
+            limit: 20,
+        });
+        const workspacePages = Array.isArray(workspaceWide?.pages)
+            ? workspaceWide.pages
+            : [];
+        return selectSingleMatch(workspacePages, "workspace");
+    }
+    async search(query, spaceId, creatorId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/search", {
+            query,
+            ...(spaceId !== undefined && { spaceId }),
+            ...(creatorId !== undefined && { creatorId }),
+        });
+        const items = response.data?.data?.items;
+        if (items !== undefined && !Array.isArray(items)) {
+            throw new Error("Unexpected API response from /search: items is not an array");
+        }
+        const filteredItems = (items ?? []).map((item) => filterSearchResult(item));
+        return {
+            items: filteredItems,
+            hasMore: false,
+        };
+    }
+    async movePage(pageId, parentPageId, position) {
+        await this.ensureAuthenticated();
+        const validPosition = position || "a00000";
+        const response = await this.client.post("/pages/move", {
+            pageId,
+            parentPageId,
+            position: validPosition,
+        });
+        return response.data;
+    }
+    async deletePage(pageId, permanentlyDelete = false) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/pages/delete", {
+            pageId,
+            permanentlyDelete,
+        });
+        return response.data;
+    }
+    async deletePages(pageIds) {
+        await this.ensureAuthenticated();
+        const results = [];
+        for (const id of pageIds) {
+            try {
+                await this.client.post("/pages/delete", { pageId: id });
+                results.push({ id, success: true });
+            }
+            catch (error) {
+                if (axios.isAxiosError(error) && (error.response?.status === 401 || error.response?.status === 403)) {
+                    throw error;
+                }
+                const msg = error instanceof Error ? error.message : String(error);
+                results.push({ id, success: false, error: msg });
+            }
+        }
+        return results;
+    }
+    async getPageHistory(pageId, limit, maxItems) {
+        const result = await this.paginateAll("/pages/history", { pageId }, limit, maxItems);
+        return { items: result.items.map((entry) => filterHistoryEntry(entry)), hasMore: result.hasMore };
+    }
+    async getPageHistoryDetail(historyId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/pages/history/info", {
+            historyId,
+        });
+        const entry = response.data.data ?? response.data;
+        const content = entry.content
+            ? convertProseMirrorToMarkdown(entry.content)
+            : "";
+        return filterHistoryDetail(entry, content);
+    }
+    async restorePage(pageId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/pages/restore", { pageId });
+        return response.data;
+    }
+    async getTrash(spaceId) {
+        const result = await this.paginateAll("/pages/trash", { spaceId });
+        return { items: result.items.map((page) => filterPage(page)), hasMore: result.hasMore };
+    }
+    async duplicatePage(pageId, spaceId) {
+        await this.ensureAuthenticated();
+        const payload = { pageId };
+        if (spaceId) {
+            payload.spaceId = spaceId;
+        }
+        const response = await this.client.post("/pages/duplicate", payload);
+        const newPage = response.data.data ?? response.data;
+        return filterPage(newPage);
+    }
+    async getSpaceInfo(spaceId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/spaces/info", { spaceId });
+        return filterSpace(response.data.data ?? response.data);
+    }
+    async createSpace(name, slug, description) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/spaces/create", {
+            name, ...(slug !== undefined && { slug }), ...(description !== undefined && { description }),
+        });
+        return filterSpace(response.data.data ?? response.data);
+    }
+    async updateSpace(spaceId, params) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/spaces/update", { spaceId, ...params });
+        return response.data;
+    }
+    async deleteSpace(spaceId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/spaces/delete", { spaceId });
+        return response.data;
+    }
+    async exportSpace(spaceId, exportFormat, includeAttachments) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/spaces/export", {
+            spaceId,
+            ...(exportFormat !== undefined && { format: exportFormat }),
+            ...(includeAttachments !== undefined && { includeAttachments }),
+        }, { responseType: "arraybuffer" });
+        return response.data;
+    }
+    async getSpaceMembers(spaceId) {
+        const result = await this.paginateAll("/spaces/members", { spaceId });
+        return { items: result.items, hasMore: result.hasMore };
+    }
+    async addSpaceMembers(spaceId, role, userIds, groupIds) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/spaces/members/add", {
+            spaceId, role, userIds: userIds ?? [], groupIds: groupIds ?? [],
+        });
+        return response.data;
+    }
+    async removeSpaceMember(spaceId, userId, groupId) {
+        await this.ensureAuthenticated();
+        const payload = { spaceId };
+        if (userId)
+            payload.userId = userId;
+        if (groupId)
+            payload.groupId = groupId;
+        const response = await this.client.post("/spaces/members/remove", payload);
+        return response.data;
+    }
+    async changeSpaceMemberRole(spaceId, role, userId, groupId) {
+        await this.ensureAuthenticated();
+        const payload = { spaceId, role };
+        if (userId)
+            payload.userId = userId;
+        if (groupId)
+            payload.groupId = groupId;
+        const response = await this.client.post("/spaces/members/change-role", payload);
+        return response.data;
+    }
+    async getWorkspacePublic() {
+        const response = await this.client.post("/workspace/public", {});
+        return response.data;
+    }
+    async updateWorkspace(params) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/workspace/update", params);
+        return response.data;
+    }
+    async getMembers() {
+        const result = await this.paginateAll("/workspace/members", {});
+        return { items: result.items.map((m) => filterMember(m)), hasMore: result.hasMore };
+    }
+    async removeMember(userId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/workspace/members/delete", { userId });
+        return response.data;
+    }
+    async changeMemberRole(userId, role) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/workspace/members/change-role", { userId, role });
+        return response.data;
+    }
+    // Invite methods
+    async getInvites() {
+        const result = await this.paginateAll("/workspace/invites", {});
+        return { items: result.items.map((i) => filterInvite(i)), hasMore: result.hasMore };
+    }
+    async getInviteInfo(invitationId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/workspace/invites/info", { invitationId });
+        return filterInvite(response.data.data ?? response.data);
+    }
+    async createInvite(emails, role, groupIds) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/workspace/invites/create", {
+            emails,
+            role,
+            groupIds: groupIds ?? [],
+        });
+        return response.data;
+    }
+    async revokeInvite(invitationId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/workspace/invites/revoke", { invitationId });
+        return response.data;
+    }
+    async resendInvite(invitationId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/workspace/invites/resend", { invitationId });
+        return response.data;
+    }
+    async getInviteLink(invitationId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/workspace/invites/link", { invitationId });
+        return response.data.data ?? response.data;
+    }
+    // User methods
+    async getCurrentUser() {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/users/me", {});
+        return filterUser(response.data.data ?? response.data);
+    }
+    async updateUser(params) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/users/update", params);
+        return response.data;
+    }
+    async getGroupInfo(groupId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/groups/info", { groupId });
+        return filterGroup(response.data.data ?? response.data);
+    }
+    async createGroup(name, description, userIds) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/groups/create", {
+            name, ...(description !== undefined && { description }), ...(userIds !== undefined && { userIds }),
+        });
+        return filterGroup(response.data.data ?? response.data);
+    }
+    async updateGroup(groupId, params) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/groups/update", { groupId, ...params });
+        return response.data;
+    }
+    async deleteGroup(groupId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/groups/delete", { groupId });
+        return response.data;
+    }
+    async getGroupMembers(groupId) {
+        const result = await this.paginateAll("/groups/members", { groupId });
+        return { items: result.items, hasMore: result.hasMore };
+    }
+    async addGroupMembers(groupId, userIds) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/groups/members/add", { groupId, userIds });
+        return response.data;
+    }
+    async removeGroupMember(groupId, userId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/groups/members/remove", { groupId, userId });
+        return response.data;
+    }
+    async getPageBreadcrumbs(pageId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/pages/breadcrumbs", { pageId });
+        const items = response.data.data ?? response.data;
+        if (!Array.isArray(items)) {
+            process.stderr.write(`Warning: getPageBreadcrumbs returned non-array response\n`);
+            return [];
+        }
+        return items.map((breadcrumb) => ({
+            id: breadcrumb.id,
+            title: breadcrumb.title,
+        }));
+    }
+    // Comment methods
+    async getComments(pageId) {
+        const result = await this.paginateAll("/comments", { pageId });
+        return { items: result.items.map((c) => filterComment(c)), hasMore: result.hasMore };
+    }
+    async getCommentInfo(commentId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/comments/info", { commentId });
+        return filterComment(response.data.data ?? response.data);
+    }
+    async createComment(pageId, content, selection, parentCommentId) {
+        await this.ensureAuthenticated();
+        const prosemirrorJson = await markdownToProseMirrorJson(content);
+        const response = await this.client.post("/comments/create", {
+            pageId,
+            content: JSON.stringify(prosemirrorJson),
+            ...(selection !== undefined && { selection }),
+            ...(parentCommentId !== undefined && { parentCommentId }),
+        });
+        return response.data;
+    }
+    async updateComment(commentId, content) {
+        await this.ensureAuthenticated();
+        const prosemirrorJson = await markdownToProseMirrorJson(content);
+        const response = await this.client.post("/comments/update", {
+            commentId,
+            content: JSON.stringify(prosemirrorJson),
+        });
+        return response.data;
+    }
+    async deleteComment(commentId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/comments/delete", { commentId });
+        return response.data;
+    }
+    // Share methods
+    async getShares() {
+        const result = await this.paginateAll("/shares", {});
+        return { items: result.items.map((s) => filterShare(s)), hasMore: result.hasMore };
+    }
+    async getShareInfo(shareId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/shares/info", { shareId });
+        return filterShare(response.data.data ?? response.data);
+    }
+    async getShareForPage(pageId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/shares/for-page", { pageId });
+        return filterShare(response.data.data ?? response.data);
+    }
+    async createShare(pageId, includeSubPages, searchIndexing) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/shares/create", {
+            pageId,
+            ...(includeSubPages !== undefined && { includeSubPages }),
+            ...(searchIndexing !== undefined && { searchIndexing }),
+        });
+        return filterShare(response.data.data ?? response.data);
+    }
+    async updateShare(shareId, includeSubPages, searchIndexing) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/shares/update", {
+            shareId,
+            ...(includeSubPages !== undefined && { includeSubPages }),
+            ...(searchIndexing !== undefined && { searchIndexing }),
+        });
+        return response.data;
+    }
+    async deleteShare(shareId) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/shares/delete", { shareId });
+        return response.data;
+    }
+    // File methods
+    async uploadFile(filePath, pageId, attachmentId) {
+        await this.ensureAuthenticated();
+        ensureFileReadable(filePath);
+        const form = new FormData();
+        form.append("file", createReadStream(filePath));
+        form.append("pageId", pageId);
+        if (attachmentId)
+            form.append("attachmentId", attachmentId);
+        const response = await axios.post(`${this.baseURL}/files/upload`, form, {
+            headers: { ...form.getHeaders(), Authorization: `Bearer ${this.token}` },
+        });
+        return response.data;
+    }
+    async downloadFile(fileId, fileName) {
+        await this.ensureAuthenticated();
+        if (!/^[\w-]+$/.test(fileId)) {
+            throw new Error(`Invalid file ID: '${fileId}'. Expected alphanumeric/UUID format.`);
+        }
+        const sanitizedName = fileName.replace(/[/\\]/g, "_").replace(/\.\./g, "_");
+        const response = await this.client.get(`/files/${fileId}/${encodeURIComponent(sanitizedName)}`, {
+            responseType: "arraybuffer",
+        });
+        return response.data;
+    }
+    // Search suggest
+    async searchSuggest(query, spaceId, options) {
+        await this.ensureAuthenticated();
+        const response = await this.client.post("/search/suggest", {
+            query, ...(spaceId !== undefined && { spaceId }), ...options,
+        });
+        return response.data.data ?? response.data;
+    }
+}