@plandesk/api 0.20.0 → 1.0.0-beta.1

package/dist/services/artifacts.js

@@ -1,5 +1,7 @@
 import { createArtifact as dbCreateArtifact, getArtifact as dbGetArtifact, getProject, listArtifactsByProject as dbListArtifactsByProject, updateArtifact as dbUpdateArtifact, } from '@plandesk/db';
 import { serializeArtifact, serializeArtifactSummary, } from '../serialize.js';
+import { assertPermission, resolveOrgId } from './org-scope.js';
+import { assertProjectInOrg, ProjectNotInOrgError } from './scope.js';
 export class InvalidArtifactError extends Error {
     constructor(message) {
         super(message);
@@ -12,58 +14,60 @@ function assertNonEmptyTitle(title) {
     }
 }
 export function createArtifactService(deps) {
-    const { db, eventBus } = deps;
+    const { db } = deps;
     return {
-        listByProject(projectId) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async listByProject(projectId) {
+            try {
+                await assertProjectInOrg(db, projectId, resolveOrgId(deps));
+            }
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
             }
-            return dbListArtifactsByProject(db, projectId).map(serializeArtifactSummary);
+            return (await dbListArtifactsByProject(db, projectId)).map(serializeArtifactSummary);
         },
-        create(projectId, input) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async create(projectId, input) {
+            assertPermission(deps, 'document', 'create');
+            try {
+                await assertProjectInOrg(db, projectId, resolveOrgId(deps));
+            }
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
             }
             assertNonEmptyTitle(input.title);
-            const artifact = dbCreateArtifact(db, {
+            const artifact = await dbCreateArtifact(db, {
                 projectId,
                 title: input.title,
                 kind: input.kind,
                 content: input.content,
             });
-            eventBus.emit({
-                type: 'artifact_created',
-                artifactId: artifact.id,
-                projectId,
-            });
             return serializeArtifact(artifact);
         },
-        get(id) {
-            const artifact = dbGetArtifact(db, id);
+        async get(id) {
+            const artifact = await dbGetArtifact(db, id);
             if (!artifact) {
                 return undefined;
             }
             return serializeArtifact(artifact);
         },
-        update(id, input) {
-            const existing = dbGetArtifact(db, id);
+        async update(id, input) {
+            assertPermission(deps, 'document', 'update');
+            const existing = await dbGetArtifact(db, id);
             if (!existing) {
                 return undefined;
             }
             if (input.title !== undefined) {
                 assertNonEmptyTitle(input.title);
             }
-            const artifact = dbUpdateArtifact(db, id, input);
+            const artifact = await dbUpdateArtifact(db, id, input);
             if (!artifact) {
                 return undefined;
             }
-            eventBus.emit({
-                type: 'artifact_updated',
-                artifactId: artifact.id,
-                projectId: artifact.projectId,
-            });
             return serializeArtifact(artifact);
         },
     };

package/dist/services/canvas.d.ts

@@ -1,8 +1,7 @@
 import { type Db } from '@plandesk/db';
-import type { EventBus } from '../events.js';
-export type CanvasServiceDeps = {
+import { type OrgScopedDeps } from './org-scope.js';
+export type CanvasServiceDeps = OrgScopedDeps & {
     db: Db;
-    eventBus: EventBus;
 };
 export type CanvasNodeInput = {
     id?: string;
@@ -28,14 +27,14 @@ export declare class InvalidCanvasError extends Error {
     constructor(message: string);
 }
 export declare function createCanvasService(deps: CanvasServiceDeps): {
-    get(projectId: string): {
+    get(projectId: string): Promise<{
         nodes: {
             tags?: import("../serialize.js").SerializedTag[] | undefined;
             id: string;
             project_id: string;
             goal_id: string;
             label: string;
-            status: "scope" | "todo" | "in_progress" | "done" | "backlog";
+            status: "in_progress" | "done" | "todo" | "scope" | "backlog";
             description: string | null;
             x: number;
             y: number;
@@ -55,13 +54,13 @@ export declare function createCanvasService(deps: CanvasServiceDeps): {
             created_at: string;
         }[];
         layout: unknown;
-    } | undefined;
+    } | undefined>;
     createEdge(projectId: string, input: {
         fromTaskId: string;
         toTaskId: string;
         label?: string | null;
         style?: string | null;
-    }): {
+    }): Promise<{
         id: string;
         project_id: string;
         from_task_id: string;
@@ -70,15 +69,15 @@ export declare function createCanvasService(deps: CanvasServiceDeps): {
         arrow_direction: string | null;
         style: string | null;
         created_at: string;
-    } | undefined;
-    putLayout(projectId: string, payload: PutCanvasLayoutInput): {
+    } | undefined>;
+    putLayout(projectId: string, payload: PutCanvasLayoutInput): Promise<{
         nodes: {
             tags?: import("../serialize.js").SerializedTag[] | undefined;
             id: string;
             project_id: string;
             goal_id: string;
             label: string;
-            status: "scope" | "todo" | "in_progress" | "done" | "backlog";
+            status: "in_progress" | "done" | "todo" | "scope" | "backlog";
             description: string | null;
             x: number;
             y: number;
@@ -98,8 +97,8 @@ export declare function createCanvasService(deps: CanvasServiceDeps): {
             created_at: string;
         }[];
         layout: unknown;
-    } | undefined;
-    deleteEdge(projectId: string, edgeId: string): boolean;
+    } | undefined>;
+    deleteEdge(projectId: string, edgeId: string): Promise<boolean>;
 };
 export type CanvasService = ReturnType<typeof createCanvasService>;
 //# sourceMappingURL=canvas.d.ts.map

package/dist/services/canvas.js

@@ -1,5 +1,7 @@
-import { createEdge, createTask, getOrCreateDefaultGoal, deleteEdge as dbDeleteEdge, getEdgeByProjectAndId, getProject, getTask, listEdges, listTasks, updateEdge, updateProject, updateTask, } from '@plandesk/db';
+import { withTransaction, createEdge, createTask, getOrCreateDefaultGoal, deleteEdge as dbDeleteEdge, getEdgeByProjectAndId, getProject, getTask, listEdges, listTasks, updateEdge, updateProject, updateTask, } from '@plandesk/db';
 import { serializeEdge, serializeTask } from '../serialize.js';
+import { assertPermission, resolveOrgId } from './org-scope.js';
+import { assertProjectInOrg, ProjectNotInOrgError } from './scope.js';
 export class InvalidCanvasError extends Error {
     constructor(message) {
         super(message);
@@ -16,10 +18,10 @@ function serializeLayout(projectLayout) {
     return parseLayout(projectLayout);
 }
 export function createCanvasService(deps) {
-    const { db, eventBus } = deps;
-    function buildCanvas(projectId, project) {
-        const tasks = listTasks(db, projectId);
-        const edgeRows = listEdges(db, projectId);
+    const { db } = deps;
+    async function buildCanvas(projectId, project) {
+        const tasks = await listTasks(db, projectId);
+        const edgeRows = await listEdges(db, projectId);
         return {
             nodes: tasks.map((task) => serializeTask(task)),
             edges: edgeRows.map(serializeEdge),
@@ -27,49 +29,65 @@ export function createCanvasService(deps) {
         };
     }
     return {
-        get(projectId) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async get(projectId) {
+            try {
+                const project = await assertProjectInOrg(db, projectId, resolveOrgId(deps));
+                return buildCanvas(projectId, project);
+            }
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
             }
-            return buildCanvas(projectId, project);
         },
-        createEdge(projectId, input) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async createEdge(projectId, input) {
+            assertPermission(deps, 'edge', 'create');
+            try {
+                await assertProjectInOrg(db, projectId, resolveOrgId(deps));
             }
-            const taskIds = new Set(listTasks(db, projectId).map((task) => task.id));
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
+            }
+            const taskIds = new Set((await listTasks(db, projectId)).map((task) => task.id));
             if (!taskIds.has(input.fromTaskId)) {
                 throw new InvalidCanvasError('Edge references missing from task');
             }
             if (!taskIds.has(input.toTaskId)) {
                 throw new InvalidCanvasError('Edge references missing to task');
             }
-            const edge = createEdge(db, {
+            const edge = await createEdge(db, {
                 projectId,
                 fromTaskId: input.fromTaskId,
                 toTaskId: input.toTaskId,
                 label: input.label ?? null,
                 style: input.style ?? null,
             });
-            eventBus.emit({ type: 'canvas_updated', projectId });
             return serializeEdge(edge);
         },
-        putLayout(projectId, payload) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async putLayout(projectId, payload) {
+            assertPermission(deps, 'task', 'update');
+            try {
+                await assertProjectInOrg(db, projectId, resolveOrgId(deps));
+            }
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
             }
             for (const node of payload.nodes) {
                 if (node.id !== undefined) {
-                    const existing = getTask(db, node.id);
+                    const existing = await getTask(db, node.id);
                     if (existing && existing.projectId !== projectId) {
                         throw new InvalidCanvasError('Task does not belong to project');
                     }
                 }
             }
-            const taskIds = new Set(listTasks(db, projectId).map((task) => task.id));
+            const taskIds = new Set((await listTasks(db, projectId)).map((task) => task.id));
             for (const edge of payload.edges) {
                 if (!taskIds.has(edge.from_task_id) &&
                     !payload.nodes.some((n) => n.id === edge.from_task_id)) {
@@ -79,21 +97,21 @@ export function createCanvasService(deps) {
                     throw new InvalidCanvasError('Edge references missing to task');
                 }
             }
-            db.transaction((tx) => {
+            await withTransaction(db, async (tx) => {
                 for (const node of payload.nodes) {
                     if (node.id !== undefined) {
-                        const existing = getTask(tx, node.id);
+                        const existing = await getTask(tx, node.id);
                         if (existing) {
-                            updateTask(tx, node.id, { x: node.x, y: node.y });
+                            await updateTask(tx, node.id, { x: node.x, y: node.y });
                             continue;
                         }
                     }
                     if (typeof node.label !== 'string' || node.label.trim() === '') {
                         throw new InvalidCanvasError('New canvas node requires label');
                     }
-                    const created = createTask(tx, {
+                    const created = await createTask(tx, {
                         projectId,
-                        goalId: getOrCreateDefaultGoal(tx, projectId).id,
+                        goalId: (await getOrCreateDefaultGoal(tx, projectId)).id,
                         id: node.id,
                         label: node.label,
                         status: 'todo',
@@ -110,11 +128,11 @@ export function createCanvasService(deps) {
                         throw new InvalidCanvasError('Edge references missing to task');
                     }
                 }
-                const existingEdges = listEdges(tx, projectId);
+                const existingEdges = await listEdges(tx, projectId);
                 const payloadEdgeIds = new Set(payload.edges.map((edge) => edge.id).filter((id) => id !== undefined));
                 for (const existingEdge of existingEdges) {
                     if (!payloadEdgeIds.has(existingEdge.id)) {
-                        dbDeleteEdge(tx, existingEdge.id);
+                        await dbDeleteEdge(tx, existingEdge.id);
                     }
                 }
                 for (const edgeInput of payload.edges) {
@@ -126,35 +144,34 @@ export function createCanvasService(deps) {
                         style: edgeInput.style ?? null,
                     };
                     if (edgeInput.id !== undefined) {
-                        const existing = getEdgeByProjectAndId(tx, projectId, edgeInput.id);
+                        const existing = await getEdgeByProjectAndId(tx, projectId, edgeInput.id);
                         if (existing) {
-                            updateEdge(tx, edgeInput.id, edgeData);
+                            await updateEdge(tx, edgeInput.id, edgeData);
                             continue;
                         }
-                        createEdge(tx, { projectId, id: edgeInput.id, ...edgeData });
+                        await createEdge(tx, { projectId, id: edgeInput.id, ...edgeData });
                         continue;
                     }
-                    createEdge(tx, { projectId, ...edgeData });
+                    await createEdge(tx, { projectId, ...edgeData });
                 }
                 const layoutJson = payload.layout === undefined ? undefined : JSON.stringify(payload.layout);
-                updateProject(tx, projectId, {
+                await updateProject(tx, projectId, {
                     ...(layoutJson !== undefined ? { canvasLayout: layoutJson } : {}),
                 });
             });
-            const updatedProject = getProject(db, projectId);
+            const updatedProject = await getProject(db, projectId);
             if (!updatedProject) {
                 return undefined;
             }
-            eventBus.emit({ type: 'canvas_updated', projectId });
             return buildCanvas(projectId, updatedProject);
         },
-        deleteEdge(projectId, edgeId) {
-            const edge = getEdgeByProjectAndId(db, projectId, edgeId);
+        async deleteEdge(projectId, edgeId) {
+            assertPermission(deps, 'edge', 'delete');
+            const edge = await getEdgeByProjectAndId(db, projectId, edgeId);
             if (!edge) {
                 return false;
             }
-            dbDeleteEdge(db, edgeId);
-            eventBus.emit({ type: 'canvas_updated', projectId });
+            await dbDeleteEdge(db, edgeId);
             return true;
         },
     };

package/dist/services/comments.d.ts

@@ -1,9 +1,8 @@
 import { type CommentTargetType, type Db } from '@plandesk/db';
-import type { EventBus } from '../events.js';
 import { type SerializedComment } from '../serialize.js';
-export type CommentServiceDeps = {
+import { type OrgScopedDeps } from './org-scope.js';
+export type CommentServiceDeps = OrgScopedDeps & {
     db: Db;
-    eventBus: EventBus;
 };
 export type CommentTarget = {
     type: CommentTargetType;
@@ -22,23 +21,23 @@ export declare class InvalidCommentError extends Error {
     constructor(message: string);
 }
 export declare function createCommentService(deps: CommentServiceDeps): {
-    create(target: CommentTarget, input: CreateCommentInput): SerializedComment | undefined;
-    createForArtifact(projectId: string, artifactId: string, input: CreateCommentInput): SerializedComment | undefined;
+    create(target: CommentTarget, input: CreateCommentInput): Promise<SerializedComment | undefined>;
+    createForArtifact(projectId: string, artifactId: string, input: CreateCommentInput): Promise<SerializedComment | undefined>;
     listForArtifact(projectId: string, artifactId: string, options?: {
         includeResolved?: boolean;
-    }): SerializedComment[] | undefined;
+    }): Promise<SerializedComment[] | undefined>;
     listByTarget(target: CommentTarget, options?: {
         includeResolved?: boolean;
-    }): SerializedComment[] | undefined;
-    resolveTargetProjectId(target: CommentTarget): string | undefined;
+    }): Promise<SerializedComment[] | undefined>;
+    resolveTargetProjectId(target: CommentTarget): Promise<string | undefined>;
     listByDocument(documentId: string, options?: {
         includeResolved?: boolean;
-    }): SerializedComment[] | undefined;
+    }): Promise<SerializedComment[] | undefined>;
     listByProject(projectId: string, options?: {
         includeResolved?: boolean;
-    }): SerializedComment[] | undefined;
-    update(id: string, input: UpdateCommentInput): SerializedComment | undefined;
-    delete(id: string): boolean;
+    }): Promise<SerializedComment[] | undefined>;
+    update(id: string, input: UpdateCommentInput): Promise<SerializedComment | undefined>;
+    delete(id: string): Promise<boolean>;
 };
 export type CommentService = ReturnType<typeof createCommentService>;
 //# sourceMappingURL=comments.d.ts.map

package/dist/services/comments.js

@@ -1,5 +1,7 @@
 import { createComment, deleteComment as dbDeleteComment, getComment as dbGetComment, getDocument as dbGetDocument, getNote as dbGetNote, getProject, getSubmission, getTask, listCommentsByProject as dbListCommentsByProject, listCommentsByTarget as dbListCommentsByTarget, updateComment as dbUpdateComment, } from '@plandesk/db';
 import { serializeComment } from '../serialize.js';
+import { assertPermission, resolveOrgId } from './org-scope.js';
+import { assertProjectInOrg, ProjectNotInOrgError } from './scope.js';
 export class InvalidCommentError extends Error {
     constructor(message) {
         super(message);
@@ -11,16 +13,16 @@ function assertNonEmptyBody(body) {
         throw new InvalidCommentError('Comment body must not be empty');
     }
 }
-function targetProjectId(db, target) {
+async function targetProjectId(db, target) {
     switch (target.type) {
         case 'document':
-            return dbGetDocument(db, target.id)?.projectId;
+            return (await dbGetDocument(db, target.id))?.projectId;
         case 'task':
-            return getTask(db, target.id)?.projectId;
+            return (await getTask(db, target.id))?.projectId;
         case 'note':
-            return dbGetNote(db, target.id)?.projectId;
+            return (await dbGetNote(db, target.id))?.projectId;
         case 'submission':
-            return getSubmission(db, target.id)?.projectId;
+            return (await getSubmission(db, target.id))?.projectId;
         case 'artifact':
             // An artifact is a file on disk, not a DB entity — its project is
             // supplied by the caller (the connected repo's project), not resolved
@@ -28,36 +30,17 @@ function targetProjectId(db, target) {
             return undefined;
     }
 }
-function emitCommentCreated(eventBus, commentId, projectId, target) {
-    eventBus.emit({
-        type: 'comment_created',
-        commentId,
-        projectId,
-        target_type: target.type,
-        target_id: target.id,
-        ...(target.type === 'document' ? { documentId: target.id } : {}),
-    });
-}
-function emitCommentUpdated(eventBus, commentId, projectId, target) {
-    eventBus.emit({
-        type: 'comment_updated',
-        commentId,
-        projectId,
-        target_type: target.type,
-        target_id: target.id,
-        ...(target.type === 'document' ? { documentId: target.id } : {}),
-    });
-}
 export function createCommentService(deps) {
-    const { db, eventBus } = deps;
+    const { db } = deps;
     return {
-        create(target, input) {
-            const projectId = targetProjectId(db, target);
+        async create(target, input) {
+            assertPermission(deps, 'comment', 'create');
+            const projectId = await targetProjectId(db, target);
             if (!projectId) {
                 return undefined;
             }
             assertNonEmptyBody(input.body);
-            const comment = createComment(db, {
+            const comment = await createComment(db, {
                 projectId,
                 targetType: target.type,
                 targetId: target.id,
@@ -65,22 +48,21 @@ export function createCommentService(deps) {
                 passage: input.passage,
                 anchor: input.anchor,
             });
-            emitCommentCreated(eventBus, comment.id, projectId, target);
             return serializeComment(comment);
         },
         // Artifact comments are project-scoped: the caller supplies the project
         // (the connected repo's), and the file identity is the target id. Slashes
         // in the file identity mean it travels in the body/query, never a path seg.
-        createForArtifact(projectId, artifactId, input) {
-            if (!getProject(db, projectId)) {
+        async createForArtifact(projectId, artifactId, input) {
+            assertPermission(deps, 'comment', 'create');
+            if (!(await getProject(db, projectId))) {
                 return undefined;
             }
             if (artifactId.trim() === '') {
                 throw new InvalidCommentError('Artifact id must not be empty');
             }
             assertNonEmptyBody(input.body);
-            const target = { type: 'artifact', id: artifactId };
-            const comment = createComment(db, {
+            const comment = await createComment(db, {
                 projectId,
                 targetType: 'artifact',
                 targetId: artifactId,
@@ -88,80 +70,78 @@ export function createCommentService(deps) {
                 passage: input.passage,
                 anchor: input.anchor,
             });
-            emitCommentCreated(eventBus, comment.id, projectId, target);
             return serializeComment(comment);
         },
-        listForArtifact(projectId, artifactId, options) {
-            if (!getProject(db, projectId)) {
+        async listForArtifact(projectId, artifactId, options) {
+            if (!(await getProject(db, projectId))) {
                 return undefined;
             }
-            return dbListCommentsByTarget(db, 'artifact', artifactId, options).map(serializeComment);
+            return (await dbListCommentsByTarget(db, 'artifact', artifactId, options)).map(serializeComment);
         },
-        listByTarget(target, options) {
-            const projectId = targetProjectId(db, target);
+        async listByTarget(target, options) {
+            const projectId = await targetProjectId(db, target);
             if (!projectId) {
                 return undefined;
             }
-            return dbListCommentsByTarget(db, target.type, target.id, options).map(serializeComment);
+            return (await dbListCommentsByTarget(db, target.type, target.id, options)).map(serializeComment);
         },
-        resolveTargetProjectId(target) {
+        async resolveTargetProjectId(target) {
             return targetProjectId(db, target);
         },
-        listByDocument(documentId, options) {
+        async listByDocument(documentId, options) {
             return this.listByTarget({ type: 'document', id: documentId }, options);
         },
-        listByProject(projectId, options) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async listByProject(projectId, options) {
+            try {
+                await assertProjectInOrg(db, projectId, resolveOrgId(deps));
             }
-            return dbListCommentsByProject(db, projectId, options).map(serializeComment);
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
+            }
+            return (await dbListCommentsByProject(db, projectId, options)).map(serializeComment);
         },
-        update(id, input) {
-            const existing = dbGetComment(db, id);
+        async update(id, input) {
+            assertPermission(deps, 'comment', 'update');
+            const existing = await dbGetComment(db, id);
             if (!existing) {
                 return undefined;
             }
             if (input.body !== undefined) {
                 assertNonEmptyBody(input.body);
             }
-            const comment = dbUpdateComment(db, id, input);
+            const comment = await dbUpdateComment(db, id, input);
             if (!comment) {
                 return undefined;
             }
-            const projectId = targetProjectId(db, {
+            const projectId = await targetProjectId(db, {
                 type: comment.targetType,
                 id: comment.targetId,
             });
             if (!projectId) {
                 return undefined;
             }
-            emitCommentUpdated(eventBus, id, projectId, {
-                type: comment.targetType,
-                id: comment.targetId,
-            });
             return serializeComment(comment);
         },
-        delete(id) {
-            const existing = dbGetComment(db, id);
+        async delete(id) {
+            assertPermission(deps, 'comment', 'delete');
+            const existing = await dbGetComment(db, id);
             if (!existing) {
                 return false;
             }
-            const projectId = targetProjectId(db, {
+            const projectId = await targetProjectId(db, {
                 type: existing.targetType,
                 id: existing.targetId,
             });
             if (!projectId) {
                 return false;
             }
-            const deleted = dbDeleteComment(db, id);
+            const deleted = await dbDeleteComment(db, id);
             if (!deleted) {
                 return false;
             }
-            emitCommentUpdated(eventBus, id, projectId, {
-                type: existing.targetType,
-                id: existing.targetId,
-            });
             return true;
         },
     };

package/dist/services/documents.d.ts

@@ -1,9 +1,8 @@
 import { type Db } from '@plandesk/db';
 import { type PaginationParams, type SerializedDocument, type SerializedDocumentFolderTree, type SerializedDocumentTree } from '../serialize.js';
-import type { EventBus } from '../events.js';
-export type DocumentServiceDeps = {
+import { type OrgScopedDeps } from './org-scope.js';
+export type DocumentServiceDeps = OrgScopedDeps & {
     db: Db;
-    eventBus: EventBus;
 };
 export type CreateDocumentInput = {
     title: string;
@@ -25,14 +24,14 @@ export declare class InvalidDocumentError extends Error {
     constructor(message: string);
 }
 export declare function createDocumentService(deps: DocumentServiceDeps): {
-    listTree(projectId: string, pagination?: PaginationParams): SerializedDocumentTree[] | undefined;
-    listFolderTree(projectId: string): SerializedDocumentFolderTree | undefined;
-    listByFolder(projectId: string, folderId: string): SerializedDocumentTree[] | undefined;
-    create(projectId: string, input: CreateDocumentInput): SerializedDocument | undefined;
-    get(id: string): SerializedDocument | undefined;
-    update(id: string, input: UpdateDocumentInput): SerializedDocument | undefined;
-    getByTask(taskId: string): SerializedDocument | undefined;
-    delete(id: string): boolean;
+    listTree(projectId: string, pagination?: PaginationParams): Promise<SerializedDocumentTree[] | undefined>;
+    listFolderTree(projectId: string): Promise<SerializedDocumentFolderTree | undefined>;
+    listByFolder(projectId: string, folderId: string): Promise<SerializedDocumentTree[] | undefined>;
+    create(projectId: string, input: CreateDocumentInput): Promise<SerializedDocument | undefined>;
+    get(id: string): Promise<SerializedDocument | undefined>;
+    update(id: string, input: UpdateDocumentInput): Promise<SerializedDocument | undefined>;
+    getByTask(taskId: string): Promise<SerializedDocument | undefined>;
+    delete(id: string): Promise<boolean>;
 };
 export type DocumentService = ReturnType<typeof createDocumentService>;
 //# sourceMappingURL=documents.d.ts.map