@adula/kit 0.2.0-alpha.3 → 1.0.0

package/build/src/admin/resource_service.d.ts

@@ -1,7 +1,7 @@
 import type { Knex } from 'knex';
 import type { ResourceRegistry } from '../resource/registry.js';
-import type { Action, RecordData, SerializedRecord } from '../resource/types.js';
-import { type Actor } from '../auth/ability.js';
+import type { Action, RecordData, Resource, SerializedRecord } from '../resource/types.js';
+import { type Actor, type KitAbility } from '../auth/ability.js';
 import type { ResourceDescription, ResourceNavigation, ResourceField } from './presentation.js';
 export type ListOptions = {
     limit?: number;
@@ -10,12 +10,21 @@ export type ListOptions = {
     sort?: string;
     direction?: 'asc' | 'desc';
     filters?: Record<string, unknown>;
+    /** Only records carrying this tag (see RecordCollaboration.setTags). */
+    tag?: string;
     estimate?: boolean;
 };
+/**
+ * Whether an actor may sort, filter or search by a field. Querying reveals values
+ * indirectly, so it needs unconditional view access at the field's level.
+ */
+export declare function canQueryField(resource: Resource, actor: Actor, ability: KitAbility, key: string): boolean;
 export declare class ResourceService {
     private db;
     private registry;
     constructor(db: Knex, registry: ResourceRegistry);
+    /** The Arabic label of a registered resource, for notifications and titles. */
+    label(name: string): string;
     /** Project navigation is derived from registered resources and the current actor. */
     navigation(actor: Actor): ResourceNavigation;
     describe(name: string, actor: Actor): ResourceDescription;
@@ -29,6 +38,17 @@ export declare class ResourceService {
     private columns;
     private find;
     private requireRecord;
+    /**
+     * Authorizes one record for collaboration features (comments, tags, assignments...).
+     * Scope and conditional rules apply exactly as for show/update.
+     */
+    access(name: string, id: number, actor: Actor, action?: Action, db?: Knex): Promise<{
+        resource: Resource;
+        record: RecordData;
+        ability: KitAbility;
+    }>;
+    /** Whether a (possibly other) actor may perform an action on a record; never throws for denial. */
+    permits(name: string, id: number, actor: Actor, action?: Action): Promise<boolean>;
     list(name: string, actor: Actor, options?: ListOptions): Promise<{
         data: SerializedRecord[];
         permissions: {
@@ -75,6 +95,11 @@ export declare class ResourceService {
         action: Action;
         fields: string[];
         actorId: number;
+        actorName: string | null;
+        /**
+         * @deprecated Always null. Kept so project-owned copies of resource-show from
+         * earlier releases still compile; they fall back to the actor id.
+         */
         actorEmail: string | null;
         createdAt: string;
     }[]>;
@@ -92,7 +117,21 @@ export declare class ResourceService {
             filterable?: boolean;
             permissionLevel?: number;
             sequence?: string;
-            type: "string" | "text" | "integer" | "money" | "boolean" | "date" | "datetime" | "json" | "attachment";
+            type: "string" | "text" | "integer" | "money" | "boolean" | "date" | "datetime" | "json";
+            key: string;
+        } | {
+            label: import("../resource/types.js").Label;
+            column?: string;
+            required?: boolean;
+            unique?: boolean;
+            sortable?: boolean;
+            searchable?: boolean;
+            filterable?: boolean;
+            permissionLevel?: number;
+            sequence?: string;
+            type: "attachment";
+            accept?: string[] | "any";
+            maxSize?: string;
             key: string;
         } | {
             label: import("../resource/types.js").Label;
@@ -166,5 +205,11 @@ export declare class ResourceService {
     /** Inline children share the parent's draft state, organization and update authority. */
     private requireInlineParents;
     transition(name: string, id: number, actor: Actor, action: 'delete' | 'submit' | 'cancel', version?: unknown, transaction?: Knex.Transaction): Promise<SerializedRecord>;
+    /**
+     * Amend-by-copy: a cancelled document is copied into a new draft that points to
+     * it through amended_from_id, together with its inline lines. The original stays
+     * cancelled and unchanged; sequence fields receive new numbers.
+     */
+    amend(name: string, id: number, actor: Actor, transaction?: Knex.Transaction): Promise<SerializedRecord>;
     private audit;
 }

package/build/src/admin/resource_service.js

@@ -8,6 +8,23 @@ import { sequence } from '../services/settings.js';
 import { recordMutation } from '../events/record_mutation.js';
 import { fieldValue } from '../resource/values.js';
 import { claimAttachment, isAttachmentId, loadAttachments, releaseAttachment, } from '../attachments/attachment_service.js';
+/** Per-process cache of planner row estimates for identical list queries. */
+const estimates = new Map();
+const ESTIMATE_TTL_MS = 30_000;
+const ESTIMATE_CACHE_LIMIT = 500;
+/**
+ * Whether an actor may sort, filter or search by a field. Querying reveals values
+ * indirectly, so it needs unconditional view access at the field's level.
+ */
+export function canQueryField(resource, actor, ability, key) {
+    const level = Math.max(resource.fields[key].permissionLevel ?? 0, resource.hidden?.includes(key) ? 1 : 0);
+    // Conditional field rules cannot safely authorize a global sort/search.
+    return (actor.permissionLevel >= level &&
+        ability.can('view', resource.name, key) &&
+        !ability.rules.some((rule) => rule.conditions &&
+            (!rule.fields || rule.fields.includes(key)) &&
+            (rule.subject === resource.name || rule.subject === 'all')));
+}
 export class ResourceService {
     db;
     registry;
@@ -15,6 +32,10 @@ export class ResourceService {
         this.db = db;
         this.registry = registry;
     }
+    /** The Arabic label of a registered resource, for notifications and titles. */
+    label(name) {
+        return this.registry.get(name).label.ar;
+    }
     /** Project navigation is derived from registered resources and the current actor. */
     navigation(actor) {
         const ability = buildAbility(actor.rules, this.registry.all());
@@ -72,7 +93,7 @@ export class ResourceService {
                     !['update', 'delete', 'submit'].includes(action) ||
                     record.docStatus === 0) &&
                 (action !== 'cancel' || (resource.submittable && record.docStatus === 1)) &&
-                action !== 'amend',
+                (action !== 'amend' || (resource.submittable && record.docStatus === 2)),
         ]));
     }
     normalizeValues(resource, record) {
@@ -147,6 +168,37 @@ export class ResourceService {
         if (!canRecord(ability, actor, resource, action, record))
             throw new KitError(403, 'E_FORBIDDEN', 'ليس لديك صلاحية لهذا الإجراء');
     }
+    /**
+     * Authorizes one record for collaboration features (comments, tags, assignments...).
+     * Scope and conditional rules apply exactly as for show/update.
+     */
+    async access(name, id, actor, action = 'view', db = this.db) {
+        let resource;
+        try {
+            resource = this.registry.get(name);
+        }
+        catch {
+            throw new KitError(404, 'E_NOT_FOUND', 'الكيان غير موجود');
+        }
+        if (!Number.isSafeInteger(id) || id <= 0)
+            throw new KitError(404, 'E_NOT_FOUND', 'السجل غير موجود');
+        const ability = this.authorizeAction(resource, actor, action);
+        const record = await this.find(db, resource, actor, ability, id);
+        this.requireRecord(ability, actor, resource, action, record);
+        return { resource, record, ability };
+    }
+    /** Whether a (possibly other) actor may perform an action on a record; never throws for denial. */
+    async permits(name, id, actor, action = 'view') {
+        try {
+            await this.access(name, id, actor, action);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof KitError && [403, 404].includes(error.status))
+                return false;
+            throw error;
+        }
+    }
     async list(name, actor, options = {}) {
         const resource = this.registry.get(name);
         const ability = this.authorizeAction(resource, actor, 'view');
@@ -177,14 +229,36 @@ export class ResourceService {
                 throw new KitError(422, 'E_FILTER', 'Invalid filter value');
             query.where(`r.${resource.fields[key].column ?? columnName(key)}`, value);
         }
+        if (options.tag !== undefined && options.tag !== null && options.tag !== '') {
+            if (typeof options.tag !== 'string' || options.tag.length > 60)
+                throw new KitError(422, 'E_FILTER', 'Invalid tag filter');
+            query.whereExists((exists) => exists
+                .from('taggables as tg')
+                .join('tags as tn', 'tn.id', 'tg.tag_id')
+                .where('tg.resource', name)
+                .whereRaw('tg.record_id = r.id')
+                .where('tn.name', options.tag));
+        }
         // Estimate the authorized, filtered query, never the deployment-wide table cardinality.
+        // Only the first page pays for the extra planner round trip; later pages keep its figure.
         let estimatedTotal;
-        if (options.estimate !== false) {
+        if (options.estimate !== false && !options.cursor) {
             const compiled = query.clone().clearSelect().select('r.id').toSQL();
-            const estimate = await this.db.raw(`EXPLAIN (FORMAT JSON) ${compiled.sql}`, [
-                ...compiled.bindings,
-            ]);
-            estimatedTotal = Number(estimate.rows[0]['QUERY PLAN'][0].Plan['Plan Rows']);
+            // The planner estimate is approximate by nature; reuse it briefly for the same
+            // authorized, filtered query instead of planning it on every first page.
+            const key = `${compiled.sql}\u0000${JSON.stringify(compiled.bindings)}`;
+            const cached = estimates.get(key);
+            if (cached && cached.at > Date.now() - ESTIMATE_TTL_MS)
+                estimatedTotal = cached.rows;
+            else {
+                const estimate = await this.db.raw(`EXPLAIN (FORMAT JSON) ${compiled.sql}`, [
+                    ...compiled.bindings,
+                ]);
+                estimatedTotal = Number(estimate.rows[0]['QUERY PLAN'][0].Plan['Plan Rows']);
+                if (estimates.size >= ESTIMATE_CACHE_LIMIT)
+                    estimates.delete(estimates.keys().next().value);
+                estimates.set(key, { rows: estimatedTotal, at: Date.now() });
+            }
         }
         if (options.cursor) {
             let cursor;
@@ -242,13 +316,7 @@ export class ResourceService {
         };
     }
     canQueryField(resource, actor, ability, key) {
-        const level = Math.max(resource.fields[key].permissionLevel ?? 0, resource.hidden?.includes(key) ? 1 : 0);
-        // Conditional field rules cannot safely authorize a global sort/search.
-        return (actor.permissionLevel >= level &&
-            ability.can('view', resource.name, key) &&
-            !ability.rules.some((rule) => rule.conditions &&
-                (!rule.fields || rule.fields.includes(key)) &&
-                (rule.subject === resource.name || rule.subject === 'all')));
+        return canQueryField(resource, actor, ability, key);
     }
     async preload(resource, records, actor) {
         const related = {};
@@ -363,13 +431,19 @@ export class ResourceService {
             .where({ 'a.resource': name, 'a.record_id': id })
             .orderBy('a.id', 'desc')
             .limit(50)
-            .select('a.id', 'a.action', 'a.changes', 'a.actor_id', 'a.created_at', 'u.email as actor_email');
+            .select('a.id', 'a.action', 'a.changes', 'a.actor_id', 'a.created_at', 'u.full_name as actor_name');
         return rows.map((row) => ({
             id: Number(row.id),
             action: String(row.action),
             fields: Array.isArray(row.changes?.fields) ? row.changes.fields : [],
             actorId: Number(row.actor_id),
-            actorEmail: row.actor_email === null ? null : String(row.actor_email),
+            // A display name only: record viewers need not be able to read account e-mails.
+            actorName: row.actor_name ? String(row.actor_name) : null,
+            /**
+             * @deprecated Always null. Kept so project-owned copies of resource-show from
+             * earlier releases still compile; they fall back to the actor id.
+             */
+            actorEmail: null,
             createdAt: new Date(row.created_at).toISOString(),
         }));
     }
@@ -540,7 +614,12 @@ export class ResourceService {
                 candidate.orgPath = unit?.path;
             }
             this.requireRecord(ability, actor, resource, action, candidate);
-            for (const key of Object.keys(form)) {
+            // Validators may add fields (defaults, transforms); those are written too, so check them.
+            const written = new Set([
+                ...Object.keys(form),
+                ...Object.keys(validated).filter((key) => key in resource.fields),
+            ]);
+            for (const key of written) {
                 const field = resource.fields[key];
                 if (!ability.can(action, subject(name, candidate), key) ||
                     (id !== undefined && !ability.can(action, subject(name, existing), key)) ||
@@ -681,7 +760,17 @@ export class ResourceService {
                     }, childId === undefined ? undefined : Number(childId), trx, { name, id: Number(row.id), action });
                 }
             }
-            await this.audit(trx, resource, actor, action, saved, Object.keys(form));
+            const changes = [];
+            if (id !== undefined)
+                for (const key of Object.keys(resource.fields)) {
+                    if (resource.fields[key].type === 'hasMany' || !(key in saved))
+                        continue;
+                    const before = existing[key] ?? null;
+                    const after = saved[key] ?? null;
+                    if (JSON.stringify(before) !== JSON.stringify(after))
+                        changes.push({ field: key, before, after });
+                }
+            await this.audit(trx, resource, actor, action, saved, Object.keys(form), changes);
             await resource.hooks?.afterSave?.(saved, context);
             return serialize(resource, await this.hydrateOne(trx, resource, saved), ability, actor);
         };
@@ -750,14 +839,101 @@ export class ResourceService {
         };
         return transaction ? work(transaction) : this.db.transaction(work);
     }
-    async audit(trx, resource, actor, action, record, fields) {
+    /**
+     * Amend-by-copy: a cancelled document is copied into a new draft that points to
+     * it through amended_from_id, together with its inline lines. The original stays
+     * cancelled and unchanged; sequence fields receive new numbers.
+     */
+    async amend(name, id, actor, transaction) {
+        const resource = this.registry.get(name);
+        if (!resource.submittable)
+            throw new KitError(409, 'E_DOCUMENT_STATE', 'Only submittable documents can be amended');
+        const ability = this.authorizeAction(resource, actor, 'amend');
+        const work = async (trx) => {
+            const source = await this.find(trx, resource, actor, ability, id, true);
+            this.requireRecord(ability, actor, resource, 'amend', source);
+            if (source.docStatus !== 2)
+                throw new KitError(409, 'E_DOCUMENT_STATE', 'Only cancelled documents can be amended');
+            const existing = await trx(name)
+                .where('amended_from_id', id)
+                .whereNull('deleted_at')
+                .first('id');
+            if (existing)
+                throw new KitError(409, 'E_ALREADY_AMENDED', 'تم تعديل هذا المستند بالنسخ من قبل');
+            const values = {
+                created_by: actor.id,
+                updated_by: actor.id,
+                doc_status: 0,
+                amended_from_id: id,
+            };
+            if (resource.scoped)
+                values.org_unit_id = source.orgUnitId;
+            if (resource.version)
+                values.version = 1;
+            const copied = [];
+            for (const [key, field] of Object.entries(resource.fields)) {
+                if (field.type === 'hasMany' || !(key in source))
+                    continue;
+                const column = field.column ?? columnName(key);
+                if (field.sequence)
+                    values[column] = await sequence(trx, field.sequence);
+                else if (field.type === 'attachment')
+                    continue;
+                else {
+                    values[column] = field.type === 'json' ? JSON.stringify(source[key]) : source[key];
+                    copied.push(key);
+                }
+            }
+            const [row] = await trx(name).insert(values).returning('*');
+            const saved = { ...fromRow(row, resource), orgPath: source.orgPath };
+            for (const field of Object.values(resource.fields)) {
+                if (field.type !== 'hasMany' || !field.inline)
+                    continue;
+                const child = this.registry.get(field.resource);
+                const foreign = child.fields[field.foreignKey].column ?? columnName(field.foreignKey);
+                const lines = await trx(child.name).where(foreign, id).whereNull('deleted_at').orderBy('id');
+                for (const line of lines) {
+                    const copy = {
+                        created_by: actor.id,
+                        updated_by: actor.id,
+                        [foreign]: row.id,
+                    };
+                    if (child.scoped)
+                        copy.org_unit_id = line.org_unit_id;
+                    if (child.version)
+                        copy.version = 1;
+                    for (const [key, childField] of Object.entries(child.fields)) {
+                        const column = childField.column ?? columnName(key);
+                        if (key === field.foreignKey ||
+                            childField.type === 'hasMany' ||
+                            childField.type === 'attachment' ||
+                            !(column in line))
+                            continue;
+                        copy[column] = childField.sequence
+                            ? await sequence(trx, childField.sequence)
+                            : childField.type === 'json'
+                                ? JSON.stringify(line[column])
+                                : line[column];
+                    }
+                    const [inserted] = await trx(child.name).insert(copy).returning('id');
+                    await this.audit(trx, child, actor, 'create', { id: inserted.id }, Object.keys(child.fields));
+                }
+            }
+            await this.audit(trx, resource, actor, 'amend', saved, copied);
+            return serialize(resource, await this.hydrateOne(trx, resource, saved), ability, actor);
+        };
+        return transaction ? work(transaction) : this.db.transaction(work);
+    }
+    async audit(trx, resource, actor, action, record, fields, changes) {
         await recordMutation(trx, {
             module: this.registry.owner(resource.name),
             resource: resource.name,
             id: record.id,
             actorId: actor.id,
+            impersonatorId: actor.impersonatorId,
             action,
             fields,
+            changes,
         });
     }
 }

package/build/src/attachments/attachment_service.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import type { JsonValue } from '../resource/types.js';
+import type { Field, JsonValue } from '../resource/types.js';
 export type AttachmentSummary = {
     id: number;
     name: string;
@@ -51,6 +51,23 @@ export type ClaimInput = {
     orgUnitId?: number | null;
     scoped: boolean;
 };
+/** Business documents, images and archives; a field widens or narrows it with `accept`. */
+export declare const DEFAULT_ATTACHMENT_EXTENSIONS: readonly string[];
+/** Unbound uploads one user may hold at once; each is removed by pruning after a day. */
+export declare const PENDING_UPLOAD_LIMIT = 50;
+/** Uploads never bound to a record are removed after this age. */
+export declare const UNBOUND_UPLOAD_TTL_MS: number;
+/** Upload constraints of an attachment field: accepted extensions (undefined = any) and size. */
+export declare function attachmentPolicy(field: Field): {
+    extnames?: string[];
+    size: string;
+};
+/** Unbound uploads of one user; hosts refuse new uploads beyond PENDING_UPLOAD_LIMIT. */
+export declare function pendingUploadCount(db: Knex, userId: number): Promise<number>;
+/** Uploads that were never bound to a record and are older than the cutoff. */
+export declare function staleUploads(db: Knex, olderThan: Date, limit?: number): Promise<AttachmentRecord[]>;
+/** Deletes the row of an upload that is still unbound; the host removes the file first. */
+export declare function forgetUpload(db: Knex, id: number): Promise<boolean>;
 export declare function attachmentUrl(id: number): string;
 export declare function isAttachmentId(value: unknown): value is number;
 /** Disk keys stay relative and slash-separated so files move between disks unchanged. */

package/build/src/attachments/attachment_service.js

@@ -2,6 +2,68 @@ import { KitError } from '../admin/errors.js';
 import { identifier } from '../resource/define_resource.js';
 const MAX_ID = 2147483647;
 const REJECTED = 'المرفق غير موجود أو لا يخصك';
+/** Business documents, images and archives; a field widens or narrows it with `accept`. */
+export const DEFAULT_ATTACHMENT_EXTENSIONS = Object.freeze([
+    'pdf',
+    'png',
+    'jpg',
+    'jpeg',
+    'gif',
+    'webp',
+    'txt',
+    'csv',
+    'doc',
+    'docx',
+    'xls',
+    'xlsx',
+    'ppt',
+    'pptx',
+    'odt',
+    'ods',
+    'odp',
+    'rtf',
+    'zip',
+]);
+/** Unbound uploads one user may hold at once; each is removed by pruning after a day. */
+export const PENDING_UPLOAD_LIMIT = 50;
+/** Uploads never bound to a record are removed after this age. */
+export const UNBOUND_UPLOAD_TTL_MS = 24 * 60 * 60 * 1000;
+/** Upload constraints of an attachment field: accepted extensions (undefined = any) and size. */
+export function attachmentPolicy(field) {
+    if (field.type !== 'attachment')
+        throw new KitError(422, 'E_FIELD_INVALID', 'الحقل ليس حقل مرفقات');
+    const accept = field.accept ?? DEFAULT_ATTACHMENT_EXTENSIONS;
+    return {
+        extnames: accept === 'any'
+            ? undefined
+            : accept.map((extname) => extname.toLowerCase().replace(/^\./, '')),
+        size: field.maxSize ?? '20mb',
+    };
+}
+/** Unbound uploads of one user; hosts refuse new uploads beyond PENDING_UPLOAD_LIMIT. */
+export async function pendingUploadCount(db, userId) {
+    const [{ count }] = await db('attachments')
+        .where('uploaded_by', userId)
+        .whereNull('record_id')
+        .whereNull('deleted_at')
+        .count('* as count');
+    return Number(count);
+}
+/** Uploads that were never bound to a record and are older than the cutoff. */
+export async function staleUploads(db, olderThan, limit = 500) {
+    const rows = await db('attachments')
+        .whereNull('record_id')
+        .where('created_at', '<', olderThan)
+        .orderBy('id')
+        .limit(limit);
+    return rows.map(fromRow);
+}
+/** Deletes the row of an upload that is still unbound; the host removes the file first. */
+export async function forgetUpload(db, id) {
+    if (!isAttachmentId(id))
+        return false;
+    return (await db('attachments').where('id', id).whereNull('record_id').delete()) > 0;
+}
 export function attachmentUrl(id) {
     return `/attachments/${id}`;
 }

package/build/src/auth/ability.d.ts

@@ -13,6 +13,8 @@ export type Actor = {
     orgPaths: string[];
     permissionLevel: number;
     rules: Rule[];
+    /** Set while an administrator acts as this user; recorded with every mutation. */
+    impersonatorId?: number;
 };
 export type KitAbility = Ability<[string, any], Conditions>;
 export declare const abilitySchemas: WeakMap<KitAbility, readonly Pick<Resource, "fields" | "name">[]>;

package/build/src/collaboration/assignments.d.ts

@@ -0,0 +1,78 @@
+import type { Knex } from 'knex';
+import type { Actor } from '../auth/ability.js';
+import type { ResourceService } from '../admin/resource_service.js';
+import type { ActorLoader } from './record_collaboration.js';
+export type AssignmentStatus = 'open' | 'done' | 'cancelled';
+export type Assignment = {
+    id: number;
+    resource: string;
+    resourceLabel: string;
+    recordId: number;
+    assigneeId: number;
+    assigneeName: string | null;
+    assignedBy: number | null;
+    assignedByName: string | null;
+    kind: string;
+    title: string;
+    note: string | null;
+    dueOn: string | null;
+    status: AssignmentStatus;
+    outcome: string | null;
+    createdAt: string;
+    completedAt: string | null;
+    /** Set for approval steps; completion goes through the workflow engine instead. */
+    workflowRunId: string | null;
+    canComplete: boolean;
+    canCancel: boolean;
+};
+export type AssignmentPage = {
+    data: Assignment[];
+    nextCursor: string | null;
+    open: number;
+};
+/**
+ * Assignments put a record on someone's "my tasks" list. Assigning needs update
+ * permission on the record, the assignee must be able to read it, and every read
+ * re-checks the record so lost access hides the task instead of leaking it.
+ */
+export declare class Assignments {
+    private db;
+    private resources;
+    private actors;
+    constructor(db: Knex, resources: ResourceService, actors: ActorLoader);
+    forRecord(name: string, id: number, actor: Actor): Promise<Assignment[]>;
+    assign(name: string, id: number, actor: Actor, input: {
+        assigneeId: unknown;
+        title: unknown;
+        note?: unknown;
+        dueOn?: unknown;
+    }): Promise<Assignment>;
+    /**
+     * Inserts an assignment and its notification. Used by assign() and by workflow
+     * approval steps inside their own transaction; callers authorize beforehand.
+     */
+    create(db: Knex, input: {
+        resource: string;
+        recordId: number;
+        assigneeId: number;
+        assignedBy: number | null;
+        title: string;
+        note?: string | null;
+        dueOn?: string | null;
+        kind?: string;
+        workflowRunId?: string;
+        workflowStep?: string;
+    }): Promise<any>;
+    /** The signed-in user's own tasks, open first; records they can no longer read are hidden. */
+    mine(actor: Actor, options?: {
+        status?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<AssignmentPage>;
+    /** The assignee marks the task done, or the assigner cancels it. */
+    complete(assignmentId: unknown, actor: Actor, outcome?: 'done' | 'cancelled'): Promise<void>;
+    private query;
+    private present;
+    private label;
+    private canView;
+}