@things-factory/worklist 10.1.248 → 10.1.250

package/dist-server/index.d.ts

@@ -0,0 +1,6 @@
+import './routes.js';
+export * from './controllers/index.js';
+export * from './service/index.js';
+export { freezeDecisionSentences, DecisionSentenceMissing } from '../shared/decision-sentences.js';
+export { freezeDecisionSentencesFor } from './service/activity/freeze-decision-sentences-for.js';
+export type { DecisionSentenceKey, Translate as DecisionSentenceTranslate } from '../shared/decision-sentences.js';

package/dist-server/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.freezeDecisionSentencesFor = exports.DecisionSentenceMissing = exports.freezeDecisionSentences = void 0;
+const tslib_1 = require("tslib");
+require("./routes.js");
+tslib_1.__exportStar(require("./controllers/index.js"), exports);
+tslib_1.__exportStar(require("./service/index.js"), exports);
+/* Freezing an approval's value sentences — the same reading of the input the decision screen uses. */
+var decision_sentences_js_1 = require("../shared/decision-sentences.js");
+Object.defineProperty(exports, "freezeDecisionSentences", { enumerable: true, get: function () { return decision_sentences_js_1.freezeDecisionSentences; } });
+Object.defineProperty(exports, "DecisionSentenceMissing", { enumerable: true, get: function () { return decision_sentences_js_1.DecisionSentenceMissing; } });
+var freeze_decision_sentences_for_js_1 = require("./service/activity/freeze-decision-sentences-for.js");
+Object.defineProperty(exports, "freezeDecisionSentencesFor", { enumerable: true, get: function () { return freeze_decision_sentences_for_js_1.freezeDecisionSentencesFor; } });
+const auth_base_1 = require("@things-factory/auth-base");
+const role_tasks_js_1 = require("./role-tasks.js");
+for (const task of role_tasks_js_1.ROLE_TASKS)
+    (0, auth_base_1.registerRoleTask)(task);
+//# sourceMappingURL=index.js.map

package/dist-server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../server/index.ts"],"names":[],"mappings":";;;;AAAA,uBAAoB;AAEpB,iEAAsC;AACtC,6DAAkC;AAElC,sGAAsG;AACtG,yEAAkG;AAAzF,gIAAA,uBAAuB,OAAA;AAAE,gIAAA,uBAAuB,OAAA;AACzD,wGAAgG;AAAvF,8IAAA,0BAA0B,OAAA;AAGnC,yDAA4D;AAC5D,mDAA4C;AAE5C,KAAK,MAAM,IAAI,IAAI,0BAAU;IAAE,IAAA,4BAAgB,EAAC,IAAI,CAAC,CAAA","sourcesContent":["import './routes.js'\n\nexport * from './controllers/index.js'\nexport * from './service/index.js'\n\n/* Freezing an approval's value sentences — the same reading of the input the decision screen uses. */\nexport { freezeDecisionSentences, DecisionSentenceMissing } from '../shared/decision-sentences.js'\nexport { freezeDecisionSentencesFor } from './service/activity/freeze-decision-sentences-for.js'\nexport type { DecisionSentenceKey, Translate as DecisionSentenceTranslate } from '../shared/decision-sentences.js'\n\nimport { registerRoleTask } from '@things-factory/auth-base'\nimport { ROLE_TASKS } from './role-tasks.js'\n\nfor (const task of ROLE_TASKS) registerRoleTask(task)\n"]}

package/dist-server/role-tasks.d.ts

@@ -0,0 +1,2 @@
+import type { RoleTask } from '@things-factory/auth-base';
+export declare const ROLE_TASKS: RoleTask[];

package/dist-server/role-tasks.js

@@ -0,0 +1,16 @@
+"use strict";
+/*
+ * The work this module names, for the seats applications build (ADR-0139 decision 11).
+ *
+ * A task holds whole privileges: each opens everything its doors open, and the words under `task.<id>` in this
+ * module's translations say what that is. Seats are put together by applications (`RoleTemplate.tasks`).
+ *
+ * Data only - `server/index.ts` registers it - so an application's tests read it without starting the framework.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROLE_TASKS = void 0;
+exports.ROLE_TASKS = [
+    { id: 'worklist.submit-approvals', grants: [{ category: 'activity', axes: ['query'] }, { category: 'activity-instance', axes: ['mutation'] }] },
+    { id: 'worklist.all-cases-reading', grants: [{ category: 'activity-instance', axes: ['query'] }] }
+];
+//# sourceMappingURL=role-tasks.js.map

package/dist-server/role-tasks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"role-tasks.js","sourceRoot":"","sources":["../server/role-tasks.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAIU,QAAA,UAAU,GAAe;IACpC,EAAE,EAAE,EAAE,2BAA2B,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,mBAAmB,EAAE,IAAI,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE;IAC/I,EAAE,EAAE,EAAE,4BAA4B,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,mBAAmB,EAAE,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;CACnG,CAAA","sourcesContent":["/*\n * The work this module names, for the seats applications build (ADR-0139 decision 11).\n *\n * A task holds whole privileges: each opens everything its doors open, and the words under `task.<id>` in this\n * module's translations say what that is. Seats are put together by applications (`RoleTemplate.tasks`).\n *\n * Data only - `server/index.ts` registers it - so an application's tests read it without starting the framework.\n */\n\nimport type { RoleTask } from '@things-factory/auth-base'\n\nexport const ROLE_TASKS: RoleTask[] = [\n  { id: 'worklist.submit-approvals', grants: [{ category: 'activity', axes: ['query'] }, { category: 'activity-instance', axes: ['mutation'] }] },\n  { id: 'worklist.all-cases-reading', grants: [{ category: 'activity-instance', axes: ['query'] }] }\n]\n"]}

package/dist-server/routes.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-server/routes.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shell_1 = require("@things-factory/shell");
+const issue_js_1 = require("./controllers/activity-instance/issue.js");
+process.on('bootstrap-module-global-public-route', (app, globalPublicRouter) => {
+    /*
+     * can add global public routes to application (auth not required, tenancy not required)
+     *
+     * ex) routes.get('/path', async(context, next) => {})
+     * ex) routes.post('/path', async(context, next) => {})
+     */
+    /* When a callback occurs from the scheduler when a scheduled dataset is on schedule, data collection task for the dataset should be issued. */
+    globalPublicRouter.post('/callback-schedule-for-activity', async (context, next) => {
+        const { client } = context.request.body;
+        if (!client || typeof client !== 'object') {
+            throw new Error('client property should be a part of callback body.');
+        }
+        const { group: domainId, key: activityId } = client;
+        if (!domainId || !activityId) {
+            throw new Error(`group(${domainId}) and key(${activityId}) properties should not be empty`);
+        }
+        if (!domainId || !activityId) {
+            throw new Error(`domainId(${domainId}) and activityId(${activityId}) properties should not be empty`);
+        }
+        await (0, shell_1.getDataSource)().transaction(async (tx) => {
+            const domain = await tx.getRepository(shell_1.Domain).findOneBy({ id: domainId });
+            if (!domain) {
+                throw new Error(`domain(${domainId}) not found`);
+            }
+            context.state = {
+                ...context.state,
+                domain,
+                tx
+            };
+            await (0, issue_js_1.issue)({
+                activityId
+            }, context);
+        });
+        context.status = 200;
+    });
+});
+process.on('bootstrap-module-global-private-route', (app, globalPrivateRouter) => {
+    /*
+     * can add global private routes to application (auth required, tenancy not required)
+     */
+});
+process.on('bootstrap-module-domain-public-route', (app, domainPublicRouter) => {
+    /*
+     * can add domain public routes to application (auth not required, tenancy required)
+     */
+});
+process.on('bootstrap-module-domain-private-route', (app, domainPrivateRouter) => {
+    /*
+     * can add domain private routes to application (auth required, tenancy required)
+     */
+});
+//# sourceMappingURL=routes.js.map

package/dist-server/routes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.js","sourceRoot":"","sources":["../server/routes.ts"],"names":[],"mappings":";;AAAA,iDAA6D;AAE7D,uEAAgE;AAEhE,OAAO,CAAC,EAAE,CAAC,sCAA6C,EAAE,CAAC,GAAG,EAAE,kBAAkB,EAAE,EAAE;IACpF;;;;;OAKG;IAEH,+IAA+I;IAC/I,kBAAkB,CAAC,IAAI,CAAC,iCAAiC,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QACjF,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,IAA+B,CAAA;QAElE,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAA;QACvE,CAAC;QAED,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,UAAU,EAAE,GAAG,MAAM,CAAA;QAEnD,IAAI,CAAC,QAAQ,IAAI,CAAC,UAAU,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,SAAS,QAAQ,aAAa,UAAU,kCAAkC,CAAC,CAAA;QAC7F,CAAC;QAED,IAAI,CAAC,QAAQ,IAAI,CAAC,UAAU,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,YAAY,QAAQ,oBAAoB,UAAU,kCAAkC,CAAC,CAAA;QACvG,CAAC;QAED,MAAM,IAAA,qBAAa,GAAE,CAAC,WAAW,CAAC,KAAK,EAAC,EAAE,EAAC,EAAE;YAC3C,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,aAAa,CAAC,cAAM,CAAC,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAA;YAEzE,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,MAAM,IAAI,KAAK,CAAC,UAAU,QAAQ,aAAa,CAAC,CAAA;YAClD,CAAC;YAED,OAAO,CAAC,KAAK,GAAG;gBACd,GAAG,OAAO,CAAC,KAAK;gBAChB,MAAM;gBACN,EAAE;aACH,CAAA;YAED,MAAM,IAAA,gBAAK,EACT;gBACE,UAAU;aACX,EACD,OAAO,CACR,CAAA;QACH,CAAC,CAAC,CAAA;QAEF,OAAO,CAAC,MAAM,GAAG,GAAG,CAAA;IACtB,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA;AAEF,OAAO,CAAC,EAAE,CAAC,uCAA8C,EAAE,CAAC,GAAG,EAAE,mBAAmB,EAAE,EAAE;IACtF;;OAEG;AACL,CAAC,CAAC,CAAA;AAEF,OAAO,CAAC,EAAE,CAAC,sCAA6C,EAAE,CAAC,GAAG,EAAE,kBAAkB,EAAE,EAAE;IACpF;;OAEG;AACL,CAAC,CAAC,CAAA;AAEF,OAAO,CAAC,EAAE,CAAC,uCAA8C,EAAE,CAAC,GAAG,EAAE,mBAAmB,EAAE,EAAE;IACtF;;OAEG;AACL,CAAC,CAAC,CAAA","sourcesContent":["import { Domain, getDataSource } from '@things-factory/shell'\nimport { ScheduleRegisterRequest } from '@things-factory/scheduler-client'\nimport { issue } from './controllers/activity-instance/issue.js'\n\nprocess.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {\n  /*\n   * can add global public routes to application (auth not required, tenancy not required)\n   *\n   * ex) routes.get('/path', async(context, next) => {})\n   * ex) routes.post('/path', async(context, next) => {})\n   */\n\n  /* When a callback occurs from the scheduler when a scheduled dataset is on schedule, data collection task for the dataset should be issued. */\n  globalPublicRouter.post('/callback-schedule-for-activity', async (context, next) => {\n    const { client } = context.request.body as ScheduleRegisterRequest\n\n    if (!client || typeof client !== 'object') {\n      throw new Error('client property should be a part of callback body.')\n    }\n\n    const { group: domainId, key: activityId } = client\n\n    if (!domainId || !activityId) {\n      throw new Error(`group(${domainId}) and key(${activityId}) properties should not be empty`)\n    }\n\n    if (!domainId || !activityId) {\n      throw new Error(`domainId(${domainId}) and activityId(${activityId}) properties should not be empty`)\n    }\n\n    await getDataSource().transaction(async tx => {\n      const domain = await tx.getRepository(Domain).findOneBy({ id: domainId })\n\n      if (!domain) {\n        throw new Error(`domain(${domainId}) not found`)\n      }\n\n      context.state = {\n        ...context.state,\n        domain,\n        tx\n      }\n\n      await issue(\n        {\n          activityId\n        },\n        context\n      )\n    })\n\n    context.status = 200\n  })\n})\n\nprocess.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {\n  /*\n   * can add global private routes to application (auth required, tenancy not required)\n   */\n})\n\nprocess.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {\n  /*\n   * can add domain public routes to application (auth not required, tenancy required)\n   */\n})\n\nprocess.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {\n  /*\n   * can add domain private routes to application (auth required, tenancy required)\n   */\n})\n"]}

package/dist-server/service/activity/activity-decision-key-item-type.d.ts

@@ -0,0 +1,206 @@
+/**
+ * The part an input value plays on the approval screen.
+ *
+ * ── The shape of the set: three tenses, and five others ───────────────────
+ * Three of the eight say something about the subject at a point in time, and the other five do not:
+ *
+ *   past     evidence       what the decision was made from   (may repeat)
+ *   present  currentState   how things stand right now
+ *   future   consequence    what approving would change       (may repeat)
+ *
+ *   subject        what this is about
+ *   reason         what a person wrote
+ *   headline       one sentence built from the values
+ *   reversibility  whether approving can be undone
+ *
+ * Every mis-slotting found so far was the same mistake in that column: currentState under
+ * consequence read the present as the future, and evidence under currentState read the past as the
+ * present. So when a ninth role is asked for, the first question is whether the value is the
+ * subject's past, present or future — if it is, one of those three already holds it. If it is not,
+ * whoever asks should be able to say what it is instead. (2026-09-10, architect's ruling)
+ *
+ * ── Why the keys and the values are spelled the same ──────────────────────
+ * type-graphql publishes an enum by its **keys** when the field names the enum type, and by its
+ * **values** when the field leaves the type off. One word in a @Field decorator therefore decides
+ * what a client receives, and a schema-improving edit far away can flip it. That has already cost
+ * this repository twice: ApprovalLineItem.participation arrives as `Reference` and was compared
+ * against `reference`, false every time; the catalog page read `NotWorklist` where its selector,
+ * i18n key and stage list all said `notworklist`.
+ *
+ * Writing each key as its own value takes the choice away — either spelling produces the same
+ * string. ActivityModelItemInoutType and ActivityModelItemType are written the same way.
+ *
+ * ── The set is closed, and widening it is the architect's call ────────────
+ * Left open as a free string, a convention becomes suffix-appending: every lane invents its own
+ * word for the same slot and the screen ends up switching on a dozen spellings, printing the
+ * unmatched ones. Adding a role here is an architecture decision, not a lane's. (2026-09-09,
+ * architect's ruling)
+ */
+export declare enum ActivityDecisionRole {
+    /** One sentence built from the values: 「폐기 30 EA」, 「3에서 1로 올림」. */
+    headline = "headline",
+    /** What the decision is about — one identifier. */
+    subject = "subject",
+    /** What the person who raised it wrote. Absent, the screen says so rather than leaving a gap. */
+    reason = "reason",
+    /**
+     * What changes on approval: 「주문 넷이 뒤로 밀린다」. The only role that may appear more than once.
+     *
+     * Named consequence rather than effect because TwinCommand.effect already means the opposite in
+     * time: { status, at, seen }, what the source reported back after the command was dispatched.
+     * That one is an observation and past; this one is a prediction and future. Using a real term for
+     * the wrong meaning is worse than coining one, and plant already writes .consequence for exactly
+     * this sense in its stop-reason dialog. (2026-09-10, architect's ruling)
+     */
+    consequence = "consequence",
+    /**
+     * What is measured to be true right now — about the world, not about the request.
+     *
+     * The other roles all describe what is being asked for. This one does not, and putting it under
+     * consequence made the screen say the opposite of the truth: the twin's current readings would
+     * have read as things the approval causes.
+     *
+     * Not named observed: ops-contract already has observedBy for which observation backs a declared
+     * property, and TwinCommand.effect is an observation too, so observed would sit in the most
+     * confusable spot between them. (2026-09-10, architect's ruling) plant never needed it because the subject's present state
+     * went into the headline (「폐기 30 EA」); the twin's instruction and its current state are two
+     * separate things, and holding them side by side is what this screen is for.
+     */
+    currentState = "currentState",
+    /**
+     * Whether approving can be undone. Drawn in the frame rather than in the body.
+     *
+     * Not a separate role for want of a place — it fits consequence well enough — but for want of
+     * weight. Listed among the consequences it reads with the same force as "four orders get pushed
+     * back", and on
+     * the twin actuation, where approving moves equipment, it is the heaviest line on the screen.
+     *
+     * ── Not the same as rejectionIsFinal ──────────────────────────────────
+     * Two "cannot be undone" facts attach to opposite actions, and the twin actuation carries both,
+     * which is what makes them look like one:
+     *
+     *   reversibility     whether **approving** can be undone   (this role, read from the input)
+     *   rejectionIsFinal  whether **rejecting** ends the case   (a column on Activity)
+     *
+     * Merging them in a screen sentence tells the reader that rejection can be taken back.
+     */
+    reversibility = "reversibility",
+    /**
+     * What the decision was made from — which inspection, against which spec, decided when.
+     *
+     * Neither consequence nor currentState: consequence is the opposite direction in time, and under
+     * currentState a past finding reads as the present state of the subject. plant's disposition
+     * approval kept its own screen for exactly these three values, and it survived the comparison not
+     * because a slot could not hold them but because no slot existed — those are different reasons,
+     * and only the second one means the set is short.
+     *
+     * plant's case for it: someone approving a concession in a regulated plant who cannot see which
+     * inspection produced the finding is approving without grounds.
+     *
+     * Repeats, because grounds come in several — there were three.
+     */
+    evidence = "evidence"
+}
+/**
+ * One value the approver reads, and the part it plays.
+ *
+ * ── Why this points at input rather than at a model item ──────────────────
+ * inputPath names a value inside the instance's input and does not go through the activity's model.
+ * That is the whole reason it is a separate array: the values an approver most needs are computed by
+ * the registering module and put on the input, not declared as model items — plant's
+ * `shift.passes` / `shift.passedBy` are exactly that. A role hung on a model item could not
+ * reach them.
+ *
+ * ── inputPath, not inputKey ───────────────────────────────────────────────
+ * ActivitySearchKeyItem.inputKey names one top-level key, because its value goes into a searchable
+ * column and a path into a list is not something that can be indexed. This field takes a path,
+ * because it points at a value to draw. The two do different work, so they carry different names —
+ * one word with two meanings would make the wrong one silent, and a name that does not exist is
+ * read as a mistake instead. (2026-09-09, architect's ruling)
+ *
+ *   'reason'          → input.reason
+ *   'shift.passes'    → input.shift.passes
+ *
+ * Dots only. No array index — drawing a list is the slot's job, not the path's — and no wildcard. A
+ * path that leads nowhere resolves to undefined and is not folded into an empty value: a `reason`
+ * that is missing and a `reason` someone left blank are different facts, and the screen draws them
+ * differently.
+ *
+ * The two declarations also address different readers. model declares the boxes a performer fills;
+ * this declares what an approver reads. Putting both on one item leaves "is this an input or
+ * something to judge by" unanswerable.
+ *
+ * Order matters. plant wrote four of these screens by hand and all four laid the slots out in the
+ * same order, which makes the order the screen's hierarchy rather than a preference — so this is an
+ * ordered array and not an object keyed by role.
+ */
+export declare class ActivityDecisionKeyItem {
+    role: ActivityDecisionRole;
+    inputPath: string;
+    name?: string;
+    tKey?: string;
+    /**
+     * i18n key for the **value**, when the value is a sentence the module would otherwise freeze.
+     *
+     * ── tKey is the label; this is the sentence ───────────────────────────
+     * Two different things were being asked of one field. The screen draws a slot as a label and a
+     * value, and they come from different places:
+     *
+     *   label   declaredLabel(slot) = t(slot.tKey, { defaultValue: name })   「설비」 「사유」
+     *   value   fieldValue(slot.value)                                       the frozen sentence
+     *
+     * Putting a sentence key in `tKey` turns the label into a developer's English name and leaves the
+     * frozen Korean where it was — the thing this is meant to remove.
+     *
+     * ── Why the sentence must not freeze ──────────────────────────────────
+     * Eighteen doors build a Korean sentence when the request is raised and `issue()` snapshots it
+     * whole. The sentence then stands in the language of whoever raised it, not whoever reads it, and
+     * an approver on another language never catches up.
+     *
+     * Values are right to freeze — an approval is a judgment about facts at a moment, so quantities,
+     * dates and counts are the record. The prose describing them is not a fact, and freezing it also
+     * loses what it described: maintenance deferral carries `impact.times` as a value but `dueAt`
+     * only inside the sentence, so editing that wording would leave no way to say which due date the
+     * approval was about. (ADR-0054 ④)
+     *
+     * ── Computed, never invented ──────────────────────────────────────────
+     * `approval.<door>.<inputPath>` — `inputPath` is the one thing unique within a door, which `role`
+     * is not (a door repeats `consequence`). Nobody writing a new door picks a key, so no table of
+     * keys grows, and a test can count every one of them.
+     *
+     * Leaving it out is how a slot stays as it is. The frozen sentence remains in `value`, so a
+     * consumer that knows nothing about this field — the plain card, the timeline, an export — draws
+     * exactly what it drew before, and a missing translation never puts English into a Korean screen.
+     */
+    valueTKey?: string;
+    /**
+     * What the sentence puts into its blanks: **name in the sentence → where the value lives.**
+     *
+     *   { what: 'equipmentName', days: 'impact.days' }   → t(valueTKey, { what: …, days: … })
+     *
+     * Every value here is an `inputPath`, and that is the point rather than a convention: a sentence
+     * may only be built from values that were snapshotted. Wanting a value with no field to read it
+     * from means the field is missing, not that params needs another source — so the rule is a shape
+     * a declaration cannot write around, and a test counts it.
+     *
+     * The names on the left belong to the sentence and only have to match the locale files.
+     */
+    params?: {
+        [name: string]: string;
+    };
+    /**
+     * Unit to print after the value, when the activity fixes the unit.
+     *
+     * Declared once, so it holds for every instance of the activity — 「30 건」 works, and a unit that
+     * varies per record does not: plant's disposition carries the unit alongside the quantity, so the
+     * same activity produces 「3 EA」 and 「12.5 KG」. Writing one of them here would attach the wrong
+     * unit to the other records, with nothing to catch it.
+     *
+     * A unit that varies belongs in the headline sentence the module builds, which is what plant did:
+     * 「LOT-A 3 EA 를 폐기합니다」. Leave this empty then.
+     *
+     * Delete this field if no activity ever turns out to fix a unit. A field nobody writes stays
+     * forever and the next person reads a meaning into it. (2026-09-10, architect's ruling)
+     */
+    unit?: string;
+}

package/dist-server/service/activity/activity-decision-key-item-type.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDecisionKeyItem = exports.ActivityDecisionRole = void 0;
+const tslib_1 = require("tslib");
+const type_graphql_1 = require("type-graphql");
+const shell_1 = require("@things-factory/shell");
+/**
+ * The part an input value plays on the approval screen.
+ *
+ * ── The shape of the set: three tenses, and five others ───────────────────
+ * Three of the eight say something about the subject at a point in time, and the other five do not:
+ *
+ *   past     evidence       what the decision was made from   (may repeat)
+ *   present  currentState   how things stand right now
+ *   future   consequence    what approving would change       (may repeat)
+ *
+ *   subject        what this is about
+ *   reason         what a person wrote
+ *   headline       one sentence built from the values
+ *   reversibility  whether approving can be undone
+ *
+ * Every mis-slotting found so far was the same mistake in that column: currentState under
+ * consequence read the present as the future, and evidence under currentState read the past as the
+ * present. So when a ninth role is asked for, the first question is whether the value is the
+ * subject's past, present or future — if it is, one of those three already holds it. If it is not,
+ * whoever asks should be able to say what it is instead. (2026-09-10, architect's ruling)
+ *
+ * ── Why the keys and the values are spelled the same ──────────────────────
+ * type-graphql publishes an enum by its **keys** when the field names the enum type, and by its
+ * **values** when the field leaves the type off. One word in a @Field decorator therefore decides
+ * what a client receives, and a schema-improving edit far away can flip it. That has already cost
+ * this repository twice: ApprovalLineItem.participation arrives as `Reference` and was compared
+ * against `reference`, false every time; the catalog page read `NotWorklist` where its selector,
+ * i18n key and stage list all said `notworklist`.
+ *
+ * Writing each key as its own value takes the choice away — either spelling produces the same
+ * string. ActivityModelItemInoutType and ActivityModelItemType are written the same way.
+ *
+ * ── The set is closed, and widening it is the architect's call ────────────
+ * Left open as a free string, a convention becomes suffix-appending: every lane invents its own
+ * word for the same slot and the screen ends up switching on a dozen spellings, printing the
+ * unmatched ones. Adding a role here is an architecture decision, not a lane's. (2026-09-09,
+ * architect's ruling)
+ */
+var ActivityDecisionRole;
+(function (ActivityDecisionRole) {
+    /** One sentence built from the values: 「폐기 30 EA」, 「3에서 1로 올림」. */
+    ActivityDecisionRole["headline"] = "headline";
+    /** What the decision is about — one identifier. */
+    ActivityDecisionRole["subject"] = "subject";
+    /** What the person who raised it wrote. Absent, the screen says so rather than leaving a gap. */
+    ActivityDecisionRole["reason"] = "reason";
+    /**
+     * What changes on approval: 「주문 넷이 뒤로 밀린다」. The only role that may appear more than once.
+     *
+     * Named consequence rather than effect because TwinCommand.effect already means the opposite in
+     * time: { status, at, seen }, what the source reported back after the command was dispatched.
+     * That one is an observation and past; this one is a prediction and future. Using a real term for
+     * the wrong meaning is worse than coining one, and plant already writes .consequence for exactly
+     * this sense in its stop-reason dialog. (2026-09-10, architect's ruling)
+     */
+    ActivityDecisionRole["consequence"] = "consequence";
+    /**
+     * What is measured to be true right now — about the world, not about the request.
+     *
+     * The other roles all describe what is being asked for. This one does not, and putting it under
+     * consequence made the screen say the opposite of the truth: the twin's current readings would
+     * have read as things the approval causes.
+     *
+     * Not named observed: ops-contract already has observedBy for which observation backs a declared
+     * property, and TwinCommand.effect is an observation too, so observed would sit in the most
+     * confusable spot between them. (2026-09-10, architect's ruling) plant never needed it because the subject's present state
+     * went into the headline (「폐기 30 EA」); the twin's instruction and its current state are two
+     * separate things, and holding them side by side is what this screen is for.
+     */
+    ActivityDecisionRole["currentState"] = "currentState";
+    /**
+     * Whether approving can be undone. Drawn in the frame rather than in the body.
+     *
+     * Not a separate role for want of a place — it fits consequence well enough — but for want of
+     * weight. Listed among the consequences it reads with the same force as "four orders get pushed
+     * back", and on
+     * the twin actuation, where approving moves equipment, it is the heaviest line on the screen.
+     *
+     * ── Not the same as rejectionIsFinal ──────────────────────────────────
+     * Two "cannot be undone" facts attach to opposite actions, and the twin actuation carries both,
+     * which is what makes them look like one:
+     *
+     *   reversibility     whether **approving** can be undone   (this role, read from the input)
+     *   rejectionIsFinal  whether **rejecting** ends the case   (a column on Activity)
+     *
+     * Merging them in a screen sentence tells the reader that rejection can be taken back.
+     */
+    ActivityDecisionRole["reversibility"] = "reversibility";
+    /**
+     * What the decision was made from — which inspection, against which spec, decided when.
+     *
+     * Neither consequence nor currentState: consequence is the opposite direction in time, and under
+     * currentState a past finding reads as the present state of the subject. plant's disposition
+     * approval kept its own screen for exactly these three values, and it survived the comparison not
+     * because a slot could not hold them but because no slot existed — those are different reasons,
+     * and only the second one means the set is short.
+     *
+     * plant's case for it: someone approving a concession in a regulated plant who cannot see which
+     * inspection produced the finding is approving without grounds.
+     *
+     * Repeats, because grounds come in several — there were three.
+     */
+    ActivityDecisionRole["evidence"] = "evidence";
+})(ActivityDecisionRole || (exports.ActivityDecisionRole = ActivityDecisionRole = {}));
+(0, type_graphql_1.registerEnumType)(ActivityDecisionRole, {
+    name: 'ActivityDecisionRole',
+    description: 'the part an input value plays on the approval screen'
+});
+/**
+ * One value the approver reads, and the part it plays.
+ *
+ * ── Why this points at input rather than at a model item ──────────────────
+ * inputPath names a value inside the instance's input and does not go through the activity's model.
+ * That is the whole reason it is a separate array: the values an approver most needs are computed by
+ * the registering module and put on the input, not declared as model items — plant's
+ * `shift.passes` / `shift.passedBy` are exactly that. A role hung on a model item could not
+ * reach them.
+ *
+ * ── inputPath, not inputKey ───────────────────────────────────────────────
+ * ActivitySearchKeyItem.inputKey names one top-level key, because its value goes into a searchable
+ * column and a path into a list is not something that can be indexed. This field takes a path,
+ * because it points at a value to draw. The two do different work, so they carry different names —
+ * one word with two meanings would make the wrong one silent, and a name that does not exist is
+ * read as a mistake instead. (2026-09-09, architect's ruling)
+ *
+ *   'reason'          → input.reason
+ *   'shift.passes'    → input.shift.passes
+ *
+ * Dots only. No array index — drawing a list is the slot's job, not the path's — and no wildcard. A
+ * path that leads nowhere resolves to undefined and is not folded into an empty value: a `reason`
+ * that is missing and a `reason` someone left blank are different facts, and the screen draws them
+ * differently.
+ *
+ * The two declarations also address different readers. model declares the boxes a performer fills;
+ * this declares what an approver reads. Putting both on one item leaves "is this an input or
+ * something to judge by" unanswerable.
+ *
+ * Order matters. plant wrote four of these screens by hand and all four laid the slots out in the
+ * same order, which makes the order the screen's hierarchy rather than a preference — so this is an
+ * ordered array and not an object keyed by role.
+ */
+let ActivityDecisionKeyItem = class ActivityDecisionKeyItem {
+};
+exports.ActivityDecisionKeyItem = ActivityDecisionKeyItem;
+tslib_1.__decorate([
+    (0, type_graphql_1.Field)(type => ActivityDecisionRole),
+    tslib_1.__metadata("design:type", String)
+], ActivityDecisionKeyItem.prototype, "role", void 0);
+tslib_1.__decorate([
+    (0, type_graphql_1.Field)({ description: "Dotted path to the value inside the instance's input, e.g. 'shift.passes'" }),
+    tslib_1.__metadata("design:type", String)
+], ActivityDecisionKeyItem.prototype, "inputPath", void 0);
+tslib_1.__decorate([
+    (0, type_graphql_1.Field)({ nullable: true, description: 'Developer-facing note. Never shown on a screen.' }),
+    tslib_1.__metadata("design:type", String)
+], ActivityDecisionKeyItem.prototype, "name", void 0);
+tslib_1.__decorate([
+    (0, type_graphql_1.Field)({ nullable: true, description: 'i18n key for the label. Without it the screen shows no label.' }),
+    tslib_1.__metadata("design:type", String)
+], ActivityDecisionKeyItem.prototype, "tKey", void 0);
+tslib_1.__decorate([
+    (0, type_graphql_1.Field)({ nullable: true, description: "i18n key for the value sentence: approval.<door>.<inputPath>" }),
+    tslib_1.__metadata("design:type", String)
+], ActivityDecisionKeyItem.prototype, "valueTKey", void 0);
+tslib_1.__decorate([
+    (0, type_graphql_1.Field)(type => shell_1.ScalarObject, { nullable: true, description: 'sentence placeholder → inputPath' }),
+    tslib_1.__metadata("design:type", Object)
+], ActivityDecisionKeyItem.prototype, "params", void 0);
+tslib_1.__decorate([
+    (0, type_graphql_1.Field)({ nullable: true, description: 'Unit to print after the value, when the activity fixes the unit' }),
+    tslib_1.__metadata("design:type", String)
+], ActivityDecisionKeyItem.prototype, "unit", void 0);
+exports.ActivityDecisionKeyItem = ActivityDecisionKeyItem = tslib_1.__decorate([
+    (0, type_graphql_1.ObjectType)({ description: 'Entity for ActivityDecisionKeyItem' })
+], ActivityDecisionKeyItem);
+//# sourceMappingURL=activity-decision-key-item-type.js.map

package/dist-server/service/activity/activity-decision-key-item-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-decision-key-item-type.js","sourceRoot":"","sources":["../../../server/service/activity/activity-decision-key-item-type.ts"],"names":[],"mappings":";;;;AAAA,+CAAkE;AAElE,iDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,IAAY,oBAgEX;AAhED,WAAY,oBAAoB;IAC9B,mEAAmE;IACnE,6CAAqB,CAAA;IACrB,mDAAmD;IACnD,2CAAmB,CAAA;IACnB,iGAAiG;IACjG,yCAAiB,CAAA;IACjB;;;;;;;;OAQG;IACH,mDAA2B,CAAA;IAC3B;;;;;;;;;;;;OAYG;IACH,qDAA6B,CAAA;IAC7B;;;;;;;;;;;;;;;;OAgBG;IACH,uDAA+B,CAAA;IAC/B;;;;;;;;;;;;;OAaG;IACH,6CAAqB,CAAA;AACvB,CAAC,EAhEW,oBAAoB,oCAApB,oBAAoB,QAgE/B;AAED,IAAA,+BAAgB,EAAC,oBAAoB,EAAE;IACrC,IAAI,EAAE,sBAAsB;IAC5B,WAAW,EAAE,sDAAsD;CACpE,CAAC,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEI,IAAM,uBAAuB,GAA7B,MAAM,uBAAuB;CAgFnC,CAAA;AAhFY,0DAAuB;AAElC;IADC,IAAA,oBAAK,EAAC,IAAI,CAAC,EAAE,CAAC,oBAAoB,CAAC;;qDACV;AAG1B;IADC,IAAA,oBAAK,EAAC,EAAE,WAAW,EAAE,2EAA2E,EAAE,CAAC;;0DACnF;AAGjB;IADC,IAAA,oBAAK,EAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,iDAAiD,EAAE,CAAC;;qDAC7E;AAGb;IADC,IAAA,oBAAK,EAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,+DAA+D,EAAE,CAAC;;qDAC3F;AAoCb;IADC,IAAA,oBAAK,EAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,8DAA8D,EAAE,CAAC;;0DACrF;AAelB;IADC,IAAA,oBAAK,EAAC,IAAI,CAAC,EAAE,CAAC,oBAAY,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,kCAAkC,EAAE,CAAC;;uDAC9D;AAiBnC;IADC,IAAA,oBAAK,EAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,iEAAiE,EAAE,CAAC;;qDAC7F;kCA/EF,uBAAuB;IADnC,IAAA,yBAAU,EAAC,EAAE,WAAW,EAAE,oCAAoC,EAAE,CAAC;GACrD,uBAAuB,CAgFnC","sourcesContent":["import { Field, ObjectType, registerEnumType } from 'type-graphql'\n\nimport { ScalarObject } from '@things-factory/shell'\n\n/**\n * The part an input value plays on the approval screen.\n *\n * ── The shape of the set: three tenses, and five others ───────────────────\n * Three of the eight say something about the subject at a point in time, and the other five do not:\n *\n *   past     evidence       what the decision was made from   (may repeat)\n *   present  currentState   how things stand right now\n *   future   consequence    what approving would change       (may repeat)\n *\n *   subject        what this is about\n *   reason         what a person wrote\n *   headline       one sentence built from the values\n *   reversibility  whether approving can be undone\n *\n * Every mis-slotting found so far was the same mistake in that column: currentState under\n * consequence read the present as the future, and evidence under currentState read the past as the\n * present. So when a ninth role is asked for, the first question is whether the value is the\n * subject's past, present or future — if it is, one of those three already holds it. If it is not,\n * whoever asks should be able to say what it is instead. (2026-09-10, architect's ruling)\n *\n * ── Why the keys and the values are spelled the same ──────────────────────\n * type-graphql publishes an enum by its **keys** when the field names the enum type, and by its\n * **values** when the field leaves the type off. One word in a @Field decorator therefore decides\n * what a client receives, and a schema-improving edit far away can flip it. That has already cost\n * this repository twice: ApprovalLineItem.participation arrives as `Reference` and was compared\n * against `reference`, false every time; the catalog page read `NotWorklist` where its selector,\n * i18n key and stage list all said `notworklist`.\n *\n * Writing each key as its own value takes the choice away — either spelling produces the same\n * string. ActivityModelItemInoutType and ActivityModelItemType are written the same way.\n *\n * ── The set is closed, and widening it is the architect's call ────────────\n * Left open as a free string, a convention becomes suffix-appending: every lane invents its own\n * word for the same slot and the screen ends up switching on a dozen spellings, printing the\n * unmatched ones. Adding a role here is an architecture decision, not a lane's. (2026-09-09,\n * architect's ruling)\n */\nexport enum ActivityDecisionRole {\n  /** One sentence built from the values: 「폐기 30 EA」, 「3에서 1로 올림」. */\n  headline = 'headline',\n  /** What the decision is about — one identifier. */\n  subject = 'subject',\n  /** What the person who raised it wrote. Absent, the screen says so rather than leaving a gap. */\n  reason = 'reason',\n  /**\n   * What changes on approval: 「주문 넷이 뒤로 밀린다」. The only role that may appear more than once.\n   *\n   * Named consequence rather than effect because TwinCommand.effect already means the opposite in\n   * time: { status, at, seen }, what the source reported back after the command was dispatched.\n   * That one is an observation and past; this one is a prediction and future. Using a real term for\n   * the wrong meaning is worse than coining one, and plant already writes .consequence for exactly\n   * this sense in its stop-reason dialog. (2026-09-10, architect's ruling)\n   */\n  consequence = 'consequence',\n  /**\n   * What is measured to be true right now — about the world, not about the request.\n   *\n   * The other roles all describe what is being asked for. This one does not, and putting it under\n   * consequence made the screen say the opposite of the truth: the twin's current readings would\n   * have read as things the approval causes.\n   *\n   * Not named observed: ops-contract already has observedBy for which observation backs a declared\n   * property, and TwinCommand.effect is an observation too, so observed would sit in the most\n   * confusable spot between them. (2026-09-10, architect's ruling) plant never needed it because the subject's present state\n   * went into the headline (「폐기 30 EA」); the twin's instruction and its current state are two\n   * separate things, and holding them side by side is what this screen is for.\n   */\n  currentState = 'currentState',\n  /**\n   * Whether approving can be undone. Drawn in the frame rather than in the body.\n   *\n   * Not a separate role for want of a place — it fits consequence well enough — but for want of\n   * weight. Listed among the consequences it reads with the same force as \"four orders get pushed\n   * back\", and on\n   * the twin actuation, where approving moves equipment, it is the heaviest line on the screen.\n   *\n   * ── Not the same as rejectionIsFinal ──────────────────────────────────\n   * Two \"cannot be undone\" facts attach to opposite actions, and the twin actuation carries both,\n   * which is what makes them look like one:\n   *\n   *   reversibility     whether **approving** can be undone   (this role, read from the input)\n   *   rejectionIsFinal  whether **rejecting** ends the case   (a column on Activity)\n   *\n   * Merging them in a screen sentence tells the reader that rejection can be taken back.\n   */\n  reversibility = 'reversibility',\n  /**\n   * What the decision was made from — which inspection, against which spec, decided when.\n   *\n   * Neither consequence nor currentState: consequence is the opposite direction in time, and under\n   * currentState a past finding reads as the present state of the subject. plant's disposition\n   * approval kept its own screen for exactly these three values, and it survived the comparison not\n   * because a slot could not hold them but because no slot existed — those are different reasons,\n   * and only the second one means the set is short.\n   *\n   * plant's case for it: someone approving a concession in a regulated plant who cannot see which\n   * inspection produced the finding is approving without grounds.\n   *\n   * Repeats, because grounds come in several — there were three.\n   */\n  evidence = 'evidence'\n}\n\nregisterEnumType(ActivityDecisionRole, {\n  name: 'ActivityDecisionRole',\n  description: 'the part an input value plays on the approval screen'\n})\n\n/**\n * One value the approver reads, and the part it plays.\n *\n * ── Why this points at input rather than at a model item ──────────────────\n * inputPath names a value inside the instance's input and does not go through the activity's model.\n * That is the whole reason it is a separate array: the values an approver most needs are computed by\n * the registering module and put on the input, not declared as model items — plant's\n * `shift.passes` / `shift.passedBy` are exactly that. A role hung on a model item could not\n * reach them.\n *\n * ── inputPath, not inputKey ───────────────────────────────────────────────\n * ActivitySearchKeyItem.inputKey names one top-level key, because its value goes into a searchable\n * column and a path into a list is not something that can be indexed. This field takes a path,\n * because it points at a value to draw. The two do different work, so they carry different names —\n * one word with two meanings would make the wrong one silent, and a name that does not exist is\n * read as a mistake instead. (2026-09-09, architect's ruling)\n *\n *   'reason'          → input.reason\n *   'shift.passes'    → input.shift.passes\n *\n * Dots only. No array index — drawing a list is the slot's job, not the path's — and no wildcard. A\n * path that leads nowhere resolves to undefined and is not folded into an empty value: a `reason`\n * that is missing and a `reason` someone left blank are different facts, and the screen draws them\n * differently.\n *\n * The two declarations also address different readers. model declares the boxes a performer fills;\n * this declares what an approver reads. Putting both on one item leaves \"is this an input or\n * something to judge by\" unanswerable.\n *\n * Order matters. plant wrote four of these screens by hand and all four laid the slots out in the\n * same order, which makes the order the screen's hierarchy rather than a preference — so this is an\n * ordered array and not an object keyed by role.\n */\n@ObjectType({ description: 'Entity for ActivityDecisionKeyItem' })\nexport class ActivityDecisionKeyItem {\n  @Field(type => ActivityDecisionRole)\n  role: ActivityDecisionRole\n\n  @Field({ description: \"Dotted path to the value inside the instance's input, e.g. 'shift.passes'\" })\n  inputPath: string\n\n  @Field({ nullable: true, description: 'Developer-facing note. Never shown on a screen.' })\n  name?: string\n\n  @Field({ nullable: true, description: 'i18n key for the label. Without it the screen shows no label.' })\n  tKey?: string\n\n  /**\n   * i18n key for the **value**, when the value is a sentence the module would otherwise freeze.\n   *\n   * ── tKey is the label; this is the sentence ───────────────────────────\n   * Two different things were being asked of one field. The screen draws a slot as a label and a\n   * value, and they come from different places:\n   *\n   *   label   declaredLabel(slot) = t(slot.tKey, { defaultValue: name })   「설비」 「사유」\n   *   value   fieldValue(slot.value)                                       the frozen sentence\n   *\n   * Putting a sentence key in `tKey` turns the label into a developer's English name and leaves the\n   * frozen Korean where it was — the thing this is meant to remove.\n   *\n   * ── Why the sentence must not freeze ──────────────────────────────────\n   * Eighteen doors build a Korean sentence when the request is raised and `issue()` snapshots it\n   * whole. The sentence then stands in the language of whoever raised it, not whoever reads it, and\n   * an approver on another language never catches up.\n   *\n   * Values are right to freeze — an approval is a judgment about facts at a moment, so quantities,\n   * dates and counts are the record. The prose describing them is not a fact, and freezing it also\n   * loses what it described: maintenance deferral carries `impact.times` as a value but `dueAt`\n   * only inside the sentence, so editing that wording would leave no way to say which due date the\n   * approval was about. (ADR-0054 ④)\n   *\n   * ── Computed, never invented ──────────────────────────────────────────\n   * `approval.<door>.<inputPath>` — `inputPath` is the one thing unique within a door, which `role`\n   * is not (a door repeats `consequence`). Nobody writing a new door picks a key, so no table of\n   * keys grows, and a test can count every one of them.\n   *\n   * Leaving it out is how a slot stays as it is. The frozen sentence remains in `value`, so a\n   * consumer that knows nothing about this field — the plain card, the timeline, an export — draws\n   * exactly what it drew before, and a missing translation never puts English into a Korean screen.\n   */\n  @Field({ nullable: true, description: \"i18n key for the value sentence: approval.<door>.<inputPath>\" })\n  valueTKey?: string\n\n  /**\n   * What the sentence puts into its blanks: **name in the sentence → where the value lives.**\n   *\n   *   { what: 'equipmentName', days: 'impact.days' }   → t(valueTKey, { what: …, days: … })\n   *\n   * Every value here is an `inputPath`, and that is the point rather than a convention: a sentence\n   * may only be built from values that were snapshotted. Wanting a value with no field to read it\n   * from means the field is missing, not that params needs another source — so the rule is a shape\n   * a declaration cannot write around, and a test counts it.\n   *\n   * The names on the left belong to the sentence and only have to match the locale files.\n   */\n  @Field(type => ScalarObject, { nullable: true, description: 'sentence placeholder → inputPath' })\n  params?: { [name: string]: string }\n\n  /**\n   * Unit to print after the value, when the activity fixes the unit.\n   *\n   * Declared once, so it holds for every instance of the activity — 「30 건」 works, and a unit that\n   * varies per record does not: plant's disposition carries the unit alongside the quantity, so the\n   * same activity produces 「3 EA」 and 「12.5 KG」. Writing one of them here would attach the wrong\n   * unit to the other records, with nothing to catch it.\n   *\n   * A unit that varies belongs in the headline sentence the module builds, which is what plant did:\n   * 「LOT-A 3 EA 를 폐기합니다」. Leave this empty then.\n   *\n   * Delete this field if no activity ever turns out to fix a unit. A field nobody writes stays\n   * forever and the next person reads a meaning into it. (2026-09-10, architect's ruling)\n   */\n  @Field({ nullable: true, description: 'Unit to print after the value, when the activity fixes the unit' })\n  unit?: string\n}\n"]}

package/dist-server/service/activity/activity-history.d.ts

@@ -0,0 +1,44 @@
+import { HistoryActionType, HistoryEntityInterface } from '@operato/typeorm-history';
+import { Role, User } from '@things-factory/auth-base';
+import { Domain } from '@things-factory/shell';
+import { ApprovalLineItem } from '@things-factory/organization';
+import { Activity, ActivityStartingType, ActivityStatus, ActivityType, ActivityUIType, AssigneeItem } from './activity.js';
+import { ActivityModelItem } from './activity-model-type.js';
+export declare class ActivityHistory implements HistoryEntityInterface<Activity> {
+    readonly id: string;
+    version?: number;
+    domain?: Domain;
+    domainId?: string;
+    name?: string;
+    description?: string;
+    activityType?: ActivityType;
+    state?: ActivityStatus;
+    model?: ActivityModelItem[];
+    priority?: number;
+    startingType?: ActivityStartingType;
+    schedule?: string;
+    timezone?: string;
+    scheduleId?: string;
+    standardTime?: number;
+    issuerRole?: Role;
+    issuerRoleId?: string;
+    assigneeRoleIds?: string[];
+    supervisoryRole?: Role;
+    supervisoryRoleId?: string;
+    assignees?: AssigneeItem[];
+    approvalLine?: ApprovalLineItem[];
+    uiType?: ActivityUIType;
+    uiSource?: string;
+    viewType?: ActivityUIType;
+    viewSource?: string;
+    reportType?: ActivityUIType;
+    reportSource?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    creator?: User;
+    creatorId?: string;
+    updater?: User;
+    updaterId?: string;
+    originalId: string;
+    action: HistoryActionType;
+}