@imenam/mcp-organizer 0.0.0-stage → 1.0.1

package/dist/src/core/store.d.ts

@@ -0,0 +1,565 @@
+import type Database from "better-sqlite3";
+import { type EntityType, type MemberRole, type RequestKind, type RequestStatus, type SpaceKind, type TaskPriority, type TaskStatus, type TaskType, type TestResultValue, type AccessLinkPurpose, type AgentOperation, type UserStatus, type VersionedEntityType } from "../../shared/schemas/enums.schema.js";
+import { type AccessLink, type AgentAction, type AgentRequest, type AgentToken, type Attachment, type Change, type ChecklistItem, type Comment, type EntityVersion, type Idea, type Invitation, type Membership, type Notification, type Session, type Space, type Tag, type Task, type TaskSnapshot, type TestCheckpoint, type TestResult, type TestReview, type User, type UserSettings } from "../../shared/schemas/entities.schema.js";
+/**
+ * Auteur d'une mutation : un utilisateur de la GUI, ou un agent qui agit avec
+ * son jeton pour une demande que ce jeton a prise, avec les droits du
+ * propriétaire du jeton.
+ */
+export type Actor = {
+    type: "user";
+    userId: string;
+} | {
+    type: "agent";
+    requestId: string;
+    tokenId: string;
+};
+/**
+ * Accès à la base. Les lectures sont libres ; toute écriture passe par
+ * `mutate`, qui l'exécute dans une transaction, vérifie les invariants,
+ * enregistre les versions des entités versionnées et alimente le journal
+ * `Change`.
+ */
+export declare class Store {
+    readonly db: Database.Database;
+    private activeMutation;
+    private emailListener;
+    constructor(db: Database.Database);
+    /** Ouvre (et migre) la base du répertoire de données. */
+    static open(dataDir: string): Store;
+    close(): void;
+    findUser(id: string): User | null;
+    getUser(id: string): User;
+    findUserByEmail(email: string): User | null;
+    countUsers(): number;
+    getUserSettings(userId: string): UserSettings;
+    findSessionByHash(idHash: string): Session | null;
+    findAccessLinkByHash(tokenHash: string): AccessLink | null;
+    /** Liens d'accès inutilisés d'un compte. */
+    listUnusedAccessLinks(userId: string): AccessLink[];
+    findAgentToken(id: string): AgentToken | null;
+    findAgentTokenByHash(tokenHash: string): AgentToken | null;
+    /** Jetons qui couvrent un espace, tous propriétaires confondus, du plus récemment utilisé au moins récemment. */
+    listAgentTokensOfSpace(spaceId: string): AgentToken[];
+    /** Jetons d'un utilisateur, du plus récent au plus ancien. */
+    listAgentTokensOf(userId: string): AgentToken[];
+    findInvitation(id: string): Invitation | null;
+    getInvitation(id: string): Invitation;
+    /** Invitations en attente (ni acceptées, ni révoquées, ni refusées) d'un espace, par date. */
+    listOpenInvitations(spaceId: string): Invitation[];
+    /** Invitations en attente adressées à une adresse, tous espaces confondus, par date. */
+    listOpenInvitationsForEmail(email: string): Invitation[];
+    findSpace(id: string): Space | null;
+    getSpace(id: string): Space;
+    findPersonalSpace(userId: string): Space | null;
+    /** Espaces dont l'utilisateur est membre : son espace personnel d'abord, puis les espaces communs par nom. */
+    listSpacesOf(userId: string): Space[];
+    listMemberships(spaceId: string): Membership[];
+    findMembership(spaceId: string, userId: string): Membership | null;
+    isMember(spaceId: string, userId: string): boolean;
+    findTask(id: string): Task | null;
+    getTask(id: string): Task;
+    /** Tâches d'un espace, par profondeur, colonne et position. */
+    listTasks(spaceId: string): Task[];
+    /** Tâche d'un espace par son numéro (`41` dans `ORG-41`). */
+    findTaskByNumber(spaceId: string, number: number): Task | null;
+    listChildren(parentId: string): Task[];
+    listAssigneeIds(taskId: string): string[];
+    listTagIds(taskId: string): string[];
+    /** Instantané d'une tâche : ses champs, ses assignés et ses tags. */
+    taskSnapshot(taskId: string): TaskSnapshot;
+    /** Assignations des tâches d'un espace. */
+    listAssignmentsInSpace(spaceId: string): {
+        taskId: string;
+        userId: string;
+    }[];
+    /** Associations tâche-tag des tâches d'un espace. */
+    listTaskTagsInSpace(spaceId: string): {
+        taskId: string;
+        tagId: string;
+    }[];
+    /** Tâches d'une colonne (espace, parent, statut) par position, sans `excludeId`. */
+    listColumn(spaceId: string, parentId: string | null, status: TaskStatus, excludeId?: string | null): Task[];
+    findTag(id: string): Tag | null;
+    /** Tags d'un espace, par nom. */
+    listTags(spaceId: string): Tag[];
+    findChecklistItem(id: string): ChecklistItem | null;
+    getChecklistItem(id: string): ChecklistItem;
+    listChecklist(taskId: string): ChecklistItem[];
+    findCheckpoint(id: string): TestCheckpoint | null;
+    getCheckpoint(id: string): TestCheckpoint;
+    /** Points de vérification d'une tâche de test, dans l'ordre. */
+    listCheckpoints(taskId: string): TestCheckpoint[];
+    /** Résultats saisis sur les points d'une tâche, tous testeurs confondus. */
+    listTestResults(taskId: string): TestResult[];
+    findTestResult(checkpointId: string, testerId: string): TestResult | null;
+    /** Reviews d'une tâche : brouillons et reviews soumises, par date de soumission. */
+    listTestReviews(taskId: string): TestReview[];
+    /** Brouillon de review d'un testeur sur une tâche. */
+    findDraftReview(taskId: string, testerId: string): TestReview | null;
+    findTestReview(id: string): TestReview | null;
+    /** Points de vérification des tâches d'un espace. */
+    listCheckpointsInSpace(spaceId: string): {
+        id: string;
+        taskId: string;
+    }[];
+    /** Résultats saisis sur les points des tâches d'un espace. */
+    listTestResultsInSpace(spaceId: string): {
+        taskId: string;
+        checkpointId: string;
+        testerId: string;
+        result: TestResultValue;
+    }[];
+    findComment(id: string): Comment | null;
+    getComment(id: string): Comment;
+    /** Commentaires d'une tâche, du plus ancien au plus récent. */
+    listComments(taskId: string): Comment[];
+    findAttachment(id: string): Attachment | null;
+    getAttachment(id: string): Attachment;
+    /** Pièces jointes d'une tâche, de la plus ancienne à la plus récente. */
+    listAttachments(taskId: string): Attachment[];
+    /** Pièces jointes d'une tâche et de toutes ses sous-tâches. */
+    listAttachmentsInSubtree(taskId: string): Attachment[];
+    /** Pièces jointes des tâches d'un espace. */
+    listAttachmentsInSpace(spaceId: string): Attachment[];
+    findIdea(id: string): Idea | null;
+    getIdea(id: string): Idea;
+    listIdeas(spaceId: string): Idea[];
+    /** Demandes de promotion (`idea_promotion`) en attente ou en cours sur les idées d'un espace. */
+    listOpenPromotionRequests(spaceId: string): AgentRequest[];
+    /** Tâches de test qui vérifient une tâche. */
+    listTestsOf(taskId: string): Task[];
+    findAgentRequest(id: string): AgentRequest | null;
+    getAgentRequest(id: string): AgentRequest;
+    /**
+     * Demandes qui visent un espace, d'un statut (toutes sans statut), au plus
+     * `limit` : les demandes en attente de la plus ancienne à la plus récente,
+     * les autres de la plus récente à la plus ancienne.
+     */
+    listAgentRequestsTargeting(spaceId: string, status: RequestStatus | null, limit: number): AgentRequest[];
+    /** Demandes d'un espace, de la plus récente à la plus ancienne, au plus `limit`. */
+    listAgentRequestsOfSpace(spaceId: string, limit: number): AgentRequest[];
+    /** Nombre de demandes en attente d'un espace. */
+    countPendingRequestsOfSpace(spaceId: string): number;
+    findAgentAction(id: string): AgentAction | null;
+    getAgentAction(id: string): AgentAction;
+    /** Actions d'une demande (son lot), dans l'ordre où l'agent les a faites. */
+    listAgentActions(requestId: string): AgentAction[];
+    /** Dernière action non annulée de l'agent sur une entité. */
+    lastLiveAgentActionOn(entityType: EntityType, entityId: string): AgentAction | null;
+    /** Auteur du dernier changement enregistré d'une entité, ou null si elle n'en a aucun. */
+    lastChangeAuthor(entityType: EntityType, entityId: string): {
+        actorType: "user" | "agent";
+        actorId: string | null;
+        requestId: string | null;
+    } | null;
+    findNotification(id: string): Notification | null;
+    getNotification(id: string): Notification;
+    /**
+     * Notifications affichées dans l'application d'un utilisateur, sur les
+     * tâches des espaces dont il est encore membre : non lues d'abord, puis de
+     * la plus récente à la plus ancienne.
+     */
+    listNotifications(userId: string, limit: number, offset: number): Notification[];
+    /** Nombre de notifications non lues affichées dans l'application d'un utilisateur. */
+    countUnreadNotifications(userId: string): number;
+    findVersion(entityType: VersionedEntityType, entityId: string, version: number): EntityVersion | null;
+    listVersions(entityType: VersionedEntityType, entityId: string): EntityVersion[];
+    /** Changements de numéro strictement supérieur à `since`, dans l'ordre. */
+    listChangesSince(since: number): Change[];
+    /**
+     * Changements postérieurs à `since` qui concernent un utilisateur : ceux des
+     * espaces dont il est membre et ceux qui le visent, au plus `limit`, dans l'ordre.
+     */
+    listChangesForUser(userId: string, since: number, limit: number): Change[];
+    /** Numéro du dernier changement, 0 si le journal est vide. */
+    lastChangeSeq(): number;
+    /**
+     * Abonne `listener` aux notifications dont le destinataire veut un e-mail :
+     * il reçoit leurs identifiants après la validation de la mutation qui les a
+     * créées.
+     */
+    setEmailListener(listener: ((notificationIds: string[]) => void) | null): void;
+    /**
+     * Point unique d'écriture. `fn` reçoit une `Mutation` et s'exécute dans une
+     * transaction exclusive ; à sa sortie, les invariants sont vérifiés sur l'état
+     * final, les versions et le journal sont écrits. Toute erreur annule
+     * l'ensemble.
+     */
+    mutate<T>(actor: Actor, fn: (tx: Mutation) => T): T;
+}
+export interface CreateUserInput {
+    /** Identifiant imposé, pour qu'un compte puisse être l'acteur de sa propre création. */
+    id?: string;
+    email: string;
+    displayName?: string | null;
+    passwordHash?: string | null;
+    status: UserStatus;
+}
+export interface UpdateUserInput {
+    displayName?: string | null;
+    passwordHash?: string | null;
+    status?: UserStatus;
+}
+export interface CreateSpaceInput {
+    name: string;
+    kind: SpaceKind;
+    ownerId: string;
+    keyPrefix: string;
+}
+export interface CreateTaskInput {
+    spaceId: string;
+    parentId?: string | null;
+    type?: TaskType;
+    title: string;
+    description?: string;
+    status?: TaskStatus;
+    priority?: TaskPriority;
+    /** Rang dans la colonne ; par défaut, après la dernière tâche de la colonne. */
+    position?: number;
+}
+export interface UpdateTaskInput {
+    title?: string;
+    description?: string;
+    status?: TaskStatus;
+    priority?: TaskPriority;
+    type?: TaskType;
+    parentId?: string | null;
+    /** Tâche vérifiée, pour une tâche de test ; null la retire. */
+    testedTaskId?: string | null;
+    /** Rang dans la colonne ; par défaut, après la dernière tâche quand la colonne change. */
+    position?: number;
+}
+export interface UpdateUserSettingsInput {
+    notifyAssignApp?: boolean;
+    notifyAssignEmail?: boolean;
+    notifyCommentApp?: boolean;
+    notifyCommentEmail?: boolean;
+}
+/** Issue de l'envoi de l'e-mail d'une notification. */
+export type NotificationEmailOutcome = {
+    sent: true;
+} | {
+    sent: false;
+    reason: string;
+};
+export interface CreateIdeaInput {
+    spaceId: string;
+    text: string;
+    origin?: "manual" | "agent";
+}
+export interface UpdateIdeaInput {
+    text?: string;
+    promotedTaskId?: string | null;
+    archived?: boolean;
+}
+/** Action de l'agent à enregistrer dans le lot de sa demande. */
+export interface AgentActionInput {
+    entityType: EntityType;
+    entityId: string;
+    operation: AgentOperation;
+    /** État de l'entité avant l'action ; null pour une création. */
+    before: unknown;
+    /** État de l'entité après l'action ; null pour une suppression. */
+    after: unknown;
+    /** Description lisible en français, affichée dans la GUI. */
+    summary: string;
+    /** Tâche concernée : la tâche elle-même, ou celle qui porte l'élément ; null pour une idée. */
+    taskId: string | null;
+}
+export interface CreateAgentRequestInput {
+    /** Espace où la demande est écrite, et où l'agent agira. */
+    targetSpaceId: string;
+    kind: RequestKind;
+    text: string;
+    contextTaskId?: string | null;
+    contextIdeaId?: string | null;
+}
+/**
+ * Écritures d'une mutation en cours. Chaque méthode applique une modification
+ * et la note ; `finish` vérifie les invariants et écrit versions et journal.
+ */
+export declare class Mutation {
+    readonly store: Store;
+    readonly actor: Actor;
+    /** Horodatage commun à toutes les écritures de la mutation. */
+    readonly now: string;
+    private readonly touched;
+    /** Notifications créées par la mutation dont le destinataire veut un e-mail. */
+    readonly emailNotificationIds: string[];
+    /** Demande pour laquelle agit l'agent, lue au début de la mutation. */
+    private readonly request;
+    /** Jeton avec lequel agit l'agent. */
+    private readonly token;
+    /** Vrai une fois vérifié que l'agent peut écrire pour sa demande. */
+    private agentWriteChecked;
+    /** Demandes créées par la mutation, dont l'espace cible est vérifié. */
+    private readonly createdRequestIds;
+    private readonly db;
+    constructor(store: Store, actor: Actor);
+    /** Utilisateur au nom de qui la mutation s'exécute : l'utilisateur, ou le propriétaire du jeton de l'agent. */
+    get actingUserId(): string;
+    private loadAgentRequest;
+    /** La demande de l'agent vise l'espace de son jeton. */
+    private assertRequestInTokenSpace;
+    /** La demande est `processing` et prise par le jeton de l'agent. */
+    private assertClaimedByToken;
+    /**
+     * L'agent n'écrit que pour une demande `processing` prise par son jeton,
+     * dans l'espace du jeton, dont le propriétaire est toujours membre.
+     * Vérifié à la première écriture d'une entité autre que la demande elle-même.
+     */
+    private assertAgentMayWrite;
+    private touch;
+    createUser(input: CreateUserInput): User;
+    updateUser(id: string, patch: UpdateUserInput): User;
+    createSession(session: Session): Session;
+    extendSession(idHash: string, expiresAt: string): void;
+    deleteSession(idHash: string): void;
+    /** Ferme les sessions d'un compte, sauf celle de `keepIdHash`. */
+    deleteSessionsOf(userId: string, keepIdHash?: string | null): void;
+    /** Supprime les sessions expirées à l'instant `now`. */
+    deleteExpiredSessions(now: string): void;
+    /**
+     * Émet un lien d'accès pour un compte. Un lien d'invitation est rattaché à
+     * son invitation, adressée à ce compte, et remplace le lien inutilisé de
+     * cette seule invitation ; un lien de réinitialisation remplace les liens de
+     * réinitialisation inutilisés du compte.
+     */
+    createAccessLink(input: {
+        userId: string;
+        purpose: AccessLinkPurpose;
+        invitationId: string | null;
+        tokenHash: string;
+        expiresAt: string;
+    }): AccessLink;
+    /** Supprime les liens inutilisés d'un compte, qui ne fonctionnent plus. */
+    discardUnusedAccessLinks(userId: string): void;
+    /** Supprime les liens inutilisés émis par une invitation. */
+    private discardInvitationLinks;
+    markAccessLinkUsed(id: string): void;
+    /** Enregistre un jeton d'agent de l'utilisateur acteur ; seul son hash est conservé. */
+    createAgentToken(input: {
+        spaceId: string;
+        name: string;
+        prefix: string;
+        tokenHash: string;
+        expiresAt: string | null;
+    }): AgentToken;
+    /** Révoque un jeton de l'utilisateur acteur ; un jeton déjà révoqué reste tel quel. */
+    revokeAgentToken(id: string): AgentToken;
+    /** Date du dernier usage d'un jeton ; le journal des changements n'en garde pas trace. */
+    recordAgentTokenUse(id: string, at: string): void;
+    /** Invite une adresse dans un espace, jusqu'à `expiresAt`. */
+    createInvitation(input: {
+        spaceId: string;
+        email: string;
+        expiresAt: string;
+    }): Invitation;
+    /** Repousse l'échéance d'une invitation en attente. */
+    renewInvitation(id: string, expiresAt: string): Invitation;
+    /** Révoque une invitation en attente ; ses liens inutilisés ne fonctionnent plus. */
+    revokeInvitation(id: string): Invitation;
+    acceptInvitation(id: string): Invitation;
+    /** Refus d'une invitation en attente par son destinataire ; ses liens inutilisés ne fonctionnent plus. */
+    declineInvitation(id: string): Invitation;
+    private openInvitation;
+    /** Note la modification d'une invitation, pour son espace et pour le compte de son destinataire. */
+    private touchInvitation;
+    /** Crée un espace et en fait de son propriétaire le membre `owner`. */
+    createSpace(input: CreateSpaceInput): Space;
+    renameSpace(id: string, name: string): Space;
+    /** Supprime un espace commun et tout son contenu. Un espace personnel ne se supprime pas. */
+    deleteSpace(id: string): void;
+    addMember(spaceId: string, userId: string, role?: MemberRole): Membership;
+    setMemberRole(spaceId: string, userId: string, role: MemberRole): Membership;
+    /** Retire un membre d'un espace et révoque ses jetons d'agent sur cet espace. */
+    removeMember(spaceId: string, userId: string): void;
+    private insertMembership;
+    createTask(input: CreateTaskInput): Task;
+    /**
+     * Modifie une tâche. Un changement de parent recalcule la profondeur de toute
+     * la sous-arborescence ; un changement de colonne sans position place la
+     * tâche en fin de colonne. Une tâche qui devient standard perd sa tâche testée.
+     */
+    updateTask(id: string, patch: UpdateTaskInput): Task;
+    /**
+     * Supprime une tâche et ses sous-tâches ; chacune reçoit une version de
+     * suppression. Les tâches de test qui vérifiaient une tâche supprimée
+     * perdent ce lien, avec une nouvelle version.
+     */
+    deleteTask(id: string): void;
+    /** Remplace les assignés (ou testeurs) d'une tâche. */
+    setAssignees(taskId: string, userIds: readonly string[]): string[];
+    /**
+     * Déplace une tâche dans la colonne `status` de son parent, juste après
+     * `afterId` (null : en tête de colonne). Son rang est pris entre ses deux
+     * nouvelles voisines ; quand leur écart est trop faible, la colonne est
+     * renumérotée.
+     */
+    moveTask(id: string, status: TaskStatus, afterId: string | null): Task;
+    /** Remplace les tags d'une tâche ; un nom absent de l'espace y crée le tag (noms comparés sans la casse). */
+    setTags(taskId: string, names: readonly string[]): Tag[];
+    private createTag;
+    /** Ajoute un élément en fin de checklist d'une tâche standard. */
+    addChecklistItem(taskId: string, text: string): ChecklistItem;
+    updateChecklistItem(id: string, patch: {
+        text?: string;
+        done?: boolean;
+    }): ChecklistItem;
+    deleteChecklistItem(id: string): void;
+    /** Recrée un élément de checklist supprimé, avec son identifiant et sa position. */
+    restoreChecklistItem(snapshot: ChecklistItem): ChecklistItem;
+    /** Place un élément de checklist juste après `afterId` (null : en tête), en renumérotant la liste si besoin. */
+    moveChecklistItem(id: string, afterId: string | null): ChecklistItem;
+    private updateChecklistItemPosition;
+    /**
+     * Rang d'un élément inséré juste après `afterId` (null : en tête) dans
+     * `items`, triés par rang. Quand les voisins sont trop proches, `renumber`
+     * reçoit les identifiants dans l'ordre et leur donne les rangs 1, 2, 3…
+     */
+    private slotAfter;
+    /** Tâche de test qui porte des points de vérification. */
+    private testTask;
+    /** Tâche de test dont l'utilisateur acteur est testeur (assigné). */
+    private testedTask;
+    /** Ajoute un point de vérification en fin de liste d'une tâche de test. */
+    addCheckpoint(taskId: string, text: string): TestCheckpoint;
+    updateCheckpoint(id: string, text: string): TestCheckpoint;
+    /** Supprime un point de vérification et les résultats saisis dessus. */
+    deleteCheckpoint(id: string): void;
+    /** Recrée un point de vérification supprimé, avec son identifiant, sa position et les résultats saisis dessus. */
+    restoreCheckpoint(snapshot: TestCheckpoint, results: readonly TestResult[]): TestCheckpoint;
+    /** Place un point de vérification juste après `afterId` (null : en tête), en renumérotant la liste si besoin. */
+    moveCheckpoint(id: string, afterId: string | null): TestCheckpoint;
+    /**
+     * Enregistre le résultat de l'utilisateur acteur sur un point : valeur,
+     * commentaire, ou les deux. Seul un testeur de la tâche saisit ses propres
+     * résultats ; un point sans résultat vaut « untested ».
+     */
+    setTestResult(checkpointId: string, patch: {
+        result?: TestResultValue;
+        comment?: string;
+    }): TestResult;
+    /** Enregistre le brouillon de review de l'utilisateur acteur, testeur de la tâche. */
+    saveReviewDraft(taskId: string, text: string): TestReview;
+    /**
+     * Soumet la review de l'utilisateur acteur avec le texte `text` : le
+     * brouillon est figé (date de soumission) et une demande `test_review` est
+     * déposée pour l'agent, dans l'espace de la tâche, avec la tâche pour contexte.
+     */
+    submitReview(taskId: string, text: string): {
+        review: TestReview;
+        request: AgentRequest;
+    };
+    /** Commentaire de l'utilisateur acteur sur une tâche. */
+    addComment(taskId: string, body: string): Comment;
+    /** Modifie un commentaire ; seul son auteur le peut. */
+    updateComment(id: string, body: string): Comment;
+    /** Supprime un commentaire ; seul son auteur le peut. */
+    deleteComment(id: string): void;
+    /** Supprime un commentaire écrit par l'agent, quel que soit l'utilisateur acteur : annulation de l'action qui l'a créé. */
+    deleteAgentComment(id: string): void;
+    private authoredComment;
+    /** Enregistre une pièce jointe dont le fichier est déjà écrit sous `storagePath`. */
+    createAttachment(input: {
+        id: string;
+        taskId: string;
+        filename: string;
+        mime: string;
+        size: number;
+        storagePath: string;
+    }): Attachment;
+    /** Supprime l'enregistrement d'une pièce jointe et le renvoie ; son fichier reste à effacer. */
+    deleteAttachment(id: string): Attachment;
+    /** Profondeur d'un enfant de `parent`, qui doit être dans l'espace `spaceId` et laisser place à un niveau de plus. */
+    private childDepth;
+    /** Vrai si `taskId` est `rootId` ou l'une de ses sous-tâches. */
+    private isInSubtree;
+    /** Nombre de niveaux de sous-tâches sous `taskId` (0 sans sous-tâche). */
+    private subtreeHeight;
+    private updateDescendantDepths;
+    /** Position après la dernière tâche de la colonne (espace, parent, statut), en ignorant `excludeId`. */
+    private endOfColumn;
+    createIdea(input: CreateIdeaInput): Idea;
+    updateIdea(id: string, patch: UpdateIdeaInput): Idea;
+    /** Supprime une idée ; sa version de suppression a un instantané nul. */
+    deleteIdea(id: string): void;
+    /** Dépose une demande `pending` de l'utilisateur acteur. */
+    createAgentRequest(input: CreateAgentRequestInput): AgentRequest;
+    /** Note la modification d'une demande, pour son espace. */
+    private touchRequest;
+    /** Demande `pending` qu'un membre de son espace modifie ou annule. */
+    private pendingRequestForUser;
+    /** Remplace le texte d'une demande en attente. */
+    updateAgentRequestText(id: string, text: string): AgentRequest;
+    /** Annule une demande en attente : l'agent ne la traitera pas. */
+    cancelAgentRequest(id: string): AgentRequest;
+    /** Repasse en attente une demande `processing` : un agent pourra la reprendre. */
+    releaseAgentRequest(id: string): AgentRequest;
+    /** Demande et jeton de l'agent acteur. */
+    private agentRequest;
+    /**
+     * L'agent prend sa demande avec son jeton : `pending` devient `processing`
+     * et la demande est réservée à ce jeton. La mise à jour conditionnelle, dans
+     * la transaction exclusive, garantit qu'un seul agent prend une demande donnée.
+     */
+    claimAgentRequest(): AgentRequest;
+    /** Termine la demande de l'agent avec son message de compte rendu. */
+    completeAgentRequest(reply: string): AgentRequest;
+    /** Termine la demande de l'agent en échec, avec la raison montrée à son auteur. */
+    failAgentRequest(reason: string): AgentRequest;
+    private finishAgentRequest;
+    /** Enregistre une action de l'agent dans le lot de sa demande, avec le rang suivant. */
+    recordAgentAction(input: AgentActionInput): AgentAction;
+    /** Marque annulée une action de l'agent, par l'utilisateur acteur. */
+    markAgentActionUndone(id: string, taskId: string | null): AgentAction;
+    /** Vrai si l'utilisateur est l'auteur humain de la mutation : on ne se notifie pas soi-même. */
+    private isActingUser;
+    /**
+     * Notifie un utilisateur selon ses préférences : la notification apparaît
+     * dans l'application si elle y est activée, et son identifiant est retenu
+     * pour l'envoi de l'e-mail si celui-ci est activé. Rien n'est créé quand les
+     * deux sont désactivés.
+     */
+    private notify;
+    /** Marque lue une notification de l'utilisateur acteur. */
+    markNotificationRead(id: string): void;
+    /** Marque lues toutes les notifications de l'utilisateur acteur ; renvoie leur nombre. */
+    markAllNotificationsRead(): number;
+    /** Enregistre l'issue de l'envoi de l'e-mail d'une notification : date d'envoi ou raison de l'échec. */
+    recordNotificationEmail(id: string, outcome: NotificationEmailOutcome): Notification;
+    /** Modifie les préférences d'un utilisateur. */
+    updateUserSettings(userId: string, patch: UpdateUserSettingsInput): UserSettings;
+    /** Vérifie les invariants sur l'état final, puis écrit les versions et le journal. */
+    finish(): void;
+    private checkInvariants;
+    /**
+     * L'agent ne touche que sa demande et des entités de l'espace cible de
+     * celle-ci ; les notifications qu'il crée visent des personnes, pas un espace.
+     */
+    private checkAgentScope;
+    /**
+     * Un espace personnel a exactement un membre, son propriétaire, et aucune
+     * invitation ; un espace commun a exactement un `owner`, son propriétaire.
+     * Les assignés (et testeurs) de ses tâches sont membres de l'espace ; les
+     * résultats et reviews d'un ancien testeur restent en historique.
+     */
+    private checkSpace;
+    /**
+     * Profondeur, parent dans le même espace, absence de cycle, position unique
+     * dans la colonne ; tâche testée portée par une tâche de test, dans le même
+     * espace, autre qu'elle-même.
+     */
+    private checkTask;
+    /**
+     * Une demande vise l'espace où elle est écrite, dont son auteur est membre.
+     * Une promotion d'idée vise l'espace de son idée, qui n'a pas d'autre
+     * promotion ouverte.
+     */
+    private checkRequestTarget;
+    /** Une version par entité versionnée modifiée ; une suppression a un instantané nul. */
+    private writeVersions;
+    /** Une ligne du journal par entité modifiée, avec l'auteur de la mutation. */
+    private writeChanges;
+}