ngx-t-workflow-typings 1.0.2 → 3.1.0

package/README.md

@@ -1,89 +1,201 @@
-# @ngx-t-workflows/shared-types
-
-Typings and interfaces for the [ngx-t-workflows](https://github.com/mashegoTerrence/ngx-t-workflows) library. Provides TypeScript interfaces, enums, and Joi schemas for workflow-related data structures and runtime validation.
-
-## Installation
-
-```bash
-npm install @ngx-t-workflows/shared-types
-```
-
-### Peer Dependencies
-
-- `ngx-t-forms-types` ^0.0.16
-- `rxjs` ^7.8.2
-
-## Usage
-
-### Interfaces and Types
-
-```typescript
-import {
-  WorkflowModel,
-  ProcessStep,
-  DocumentWorkflowStep,
-  WorkFlowDocumentInterface,
-  WorkflowStepTypeEnum,
-  WorkflowStepStatus,
-} from '@ngx-t-workflows/shared-types';
-```
-
-### Runtime Validation (Joi Schemas)
-
-```typescript
-import {
-  validateProcessStep,
-  validateWorkflowModel,
-  validateWorkFlowDocument,
-  validateTaskSLAConfig,
-  validateITransactionTag,
-} from '@ngx-t-workflows/shared-types';
-
-const errors = validateProcessStep(stepData);
-if (errors.length > 0) {
-  console.error('Validation failed:', errors);
-}
-```
-
-### Schemas (for custom validation)
-
-```typescript
-import {
-  processStepSchema,
-  workflowModelSchema,
-  workFlowDocumentSchema,
-} from '@ngx-t-workflows/shared-types';
-
-const { error, value } = processStepSchema.validate(data);
-```
-
-## Package Structure
-
-| Path | Contents |
-|------|----------|
-| `interfaces/Backend` | Follow-up operations, escalation levels |
-| `interfaces/Config` | NgxTWorkflowsConfig, element editor config |
-| `interfaces/Document` | WorkFlowDocument, IRecentlyViewed |
-| `interfaces/DocumentSection` | Document section configurations |
-| `interfaces/Diagram` | Workflow diagram nodes, connections, state |
-| `interfaces/ProcessStep` | ProcessStep, DocumentWorkflowStep, step types |
-| `interfaces/Schedule` | Duration, WorkSchedule, TaskSLAConfig |
-| `interfaces/Tag` | Transaction tags, metadata, assignments |
-| `interfaces/Workflow` | WorkflowModel, WorkflowNodeData |
-| `schemas/*` | Joi schemas and `validate*` helpers |
-
-## Development
-
-```bash
-npm install
-npm run build
-npm run typecheck
-```
-
-## Publishing
-
-See [PUBLISH-CHECKLIST.md](./PUBLISH-CHECKLIST.md) for step-by-step publishing instructions. See [RULES.md](./RULES.md) for versioning guidelines and security practices.
-
-## License
-
-ISC
+# ngx-t-workflow-typings
+
+Typings and interfaces for the [ngx-t-workflows](https://github.com/mashegoTerrence/ngx-t-workflows) library. Provides TypeScript interfaces, enums, and Joi schemas for workflow-related data structures and runtime validation.
+
+## Installation
+
+```bash
+npm install ngx-t-workflow-typings
+```
+
+### Peer Dependencies
+
+- `ngx-t-forms-types` >=0.0.16
+- `rxjs` >=7.8.0
+
+## Entry points
+
+Three subpaths. Import types from `./interfaces` in a browser bundle — the root
+entry re-exports the Joi schemas, so importing a type from it drags `joi` into
+the module graph.
+
+| Specifier | Contents | Pulls `joi`? |
+|---|---|---|
+| `ngx-t-workflow-typings` | interfaces + enums + Joi schemas (back-compat) | yes |
+| `ngx-t-workflow-typings/interfaces` | interfaces + enums only | **no** |
+| `ngx-t-workflow-typings/schemas` | Joi schemas and `validate*` helpers | yes |
+
+`main`/`types` still point at the root build for resolvers that ignore
+`exports`, and `./dist/*` stays addressable so existing deep imports keep working.
+
+```typescript
+// Angular app / anything bundled for the browser
+import { WorkflowStepStatus, type ProcessStep } from 'ngx-t-workflow-typings/interfaces';
+
+// Backend validation
+import { validateProcessStep } from 'ngx-t-workflow-typings/schemas';
+```
+
+## Strict enums
+
+Fields with a well-defined value set are typed with real enums, not string
+literals. Assigning a raw literal is a compile error by design:
+
+```typescript
+step.status = 'complete';                    // ✗ error
+step.status = WorkflowStepStatus.COMPLETE;   // ✓
+```
+
+The permissive predecessors (`WorkflowStepStatusValue`, `EscalationLevelType`,
+`EscalationLevelPeriodType`, `RecentlyViewedStatusType`, `AdjudicationValue`,
+`LegacyBulkEmailConfig`, `LegacyDocumentWorkflowStep`,
+`LegacyDocumentActivityLog`, `LooseDeepBindPath`, and
+`StepValidationOverride.attachment.type`) remain exported and are each tagged
+`@deprecated` naming the replacement. They are removed in the next major.
+
+### Persisted vs. presentation step kinds
+
+`WorkflowStepTypeEnum` is DB-constrained (`stepType: { type: String, enum:
+Object.values(WorkflowStepTypeEnum) }`) and holds only the 12 persisted kinds.
+Client-synthesised placeholder rows (`'upcoming'`, `'error'`) live in a separate
+`SyntheticStepType` enum, and `DisplayStepType` is the union of both. Use
+`DisplayStepType` for view models; never for anything written to the database.
+
+## Usage
+
+### Interfaces and Types
+
+```typescript
+import {
+  WorkflowModel,
+  ProcessStep,
+  DocumentWorkflowStep,
+  WorkFlowDocumentInterface,
+  WorkflowStepTypeEnum,
+  WorkflowStepStatus,
+} from 'ngx-t-workflow-typings';
+```
+
+### Runtime Validation (Joi Schemas)
+
+```typescript
+import {
+  validateProcessStep,
+  validateWorkflowModel,
+  validateWorkFlowDocument,
+  validateTaskSLAConfig,
+  validateITransactionTag,
+} from 'ngx-t-workflow-typings';
+
+const errors = validateProcessStep(stepData);
+if (errors.length > 0) {
+  console.error('Validation failed:', errors);
+}
+```
+
+### Schemas (for custom validation)
+
+```typescript
+import {
+  processStepSchema,
+  workflowModelSchema,
+  workFlowDocumentSchema,
+} from 'ngx-t-workflow-typings';
+
+const { error, value } = processStepSchema.validate(data);
+```
+
+## Step validation — two layers
+
+| Layer | API | Asks | Import from |
+|---|---|---|---|
+| Per-field | `validateProcessStepForType(step, stepType)` | Is this field filled in and correctly typed? | `/schemas` (pulls `joi`) |
+| Cross-reference | `validateStepReferences(step, ctx?)` | Does what it points AT exist, and is it the right kind of thing? | `/interfaces` (**no `joi`**) |
+
+Run both; they do not overlap. An empty field is reported only by the per-field
+layer, a dangling pointer only by the cross-reference layer.
+
+### Cross-reference validation is tri-state
+
+The forms catalog is unsound for negative conclusions — the host filters it to
+the user's department and swallows load errors into empty pools — so
+"not in the pool" never means "does not exist". Every check resolves to
+`satisfied | violated | indeterminate`.
+
+**`indeterminate` never enters `errors`, never makes `valid` false, and must
+never render as an error.** It is also not a pass. Omit the context and
+everything catalog-dependent is `indeterminate`.
+
+```typescript
+import {
+  validateStepReferences,
+  ReferenceCatalogStatus,
+} from 'ngx-t-workflow-typings/interfaces';
+
+const result = validateStepReferences(step, {
+  forms: formIndex,                    // Map<formId, { byControlName: Map<name, input> }>
+  workflows: workflowIndex,            // Map<workflowId, { initiateStepId, initiateFormId, initiateReference }>
+  processTree: stepIndex,              // Map<String(stepId), step>
+  workflowControlNames: unionSet,      // Set<formControlName>
+});
+
+if (!result.valid) blockSave(result.errors);   // never contains `indeterminate`
+showPending(result.indeterminate);             // "not checked yet"
+```
+
+### The caller owns the indexes
+
+The validator builds nothing. Build these once per emission and memoise them —
+with them every check is O(1); a full pass over a step is O(rules), max 6.
+
+| Context member | Shape | Rebuild when | Cost |
+|---|---|---|---|
+| `forms` | `Map<formId, { byControlName: Map<name, input> }>` | forms catalog emits | O(F × cols) |
+| `workflows` | `Map<workflowId, { initiateStepId, initiateFormId, initiateReference }>` | workflow pool emits | O(W + V′) |
+| `processTree` | `Map<String(stepId), step>` (an array also works, at O(V) per link) | steps change | O(V) |
+| `workflowControlNames` | `Set<formControlName>` unioned over bound forms | forms catalog emits | O(F × cols) |
+
+Pass `status: ReferenceCatalogStatus.Pending | Ready | Failed` explicitly — do
+not let the validator infer readiness from `size === 0`, because an empty pool is
+a legitimate outcome of both the department filter and the error fallback.
+
+### Catalog-free rules
+
+The five step→step rules (`CATALOG_FREE_STEP_REFERENCE_RULES`) resolve against
+the workflow's own `processTree` and are definitive the moment you pass it — no
+external catalog, no async, safe in a synchronous per-keystroke validation pass.
+
+`EXCLUDED_STEP_REFERENCES` records, as data, the references that look
+validatable and deliberately are not, with the evidence for each.
+
+## Package Structure
+
+| Path | Contents |
+|------|----------|
+| `interfaces/Backend` | Follow-up operations, escalation levels |
+| `interfaces/Config` | NgxTWorkflowsConfig, element editor config |
+| `interfaces/Document` | WorkFlowDocument, IRecentlyViewed |
+| `interfaces/DocumentSection` | Document section configurations |
+| `interfaces/Diagram` | Workflow diagram nodes, connections, reference pools |
+| `interfaces/ProcessStep` | ProcessStep, DocumentWorkflowStep, step types |
+| `interfaces/Requirements` | Per-field requirements map, cross-reference rules, both validators |
+| `interfaces/Schedule` | Duration, WorkSchedule, TaskSLAConfig |
+| `interfaces/Tag` | Transaction tags, metadata, assignments |
+| `interfaces/Workflow` | WorkflowModel (lean), DbWorkflowModel |
+| `schemas/*` | Joi schemas and `validate*` helpers |
+
+## Development
+
+```bash
+npm install
+npm run build
+npm run typecheck
+```
+
+## Publishing
+
+See [PUBLISH-CHECKLIST.md](./PUBLISH-CHECKLIST.md) for step-by-step publishing instructions. See [RULES.md](./RULES.md) for versioning guidelines and security practices.
+
+## License
+
+ISC

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * from './interfaces/index';
-export * from './schemas/index';
+export * from './interfaces/index.js';
+export * from './schemas/index.js';

package/dist/index.js

@@ -1,18 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./interfaces/index"), exports);
-__exportStar(require("./schemas/index"), exports);
+export * from './interfaces/index.js';
+export * from './schemas/index.js';

package/dist/interfaces/Backend/EscalationLevel.interface.d.ts

@@ -1,16 +1,54 @@
+/**
+ * Escalation mechanism for a workflow step.
+ *
+ * NOTE: `SeniorEscalation = 'seniorEsalation'` is misspelled in its VALUE. The
+ * spelling is preserved verbatim because it is what is persisted in the database
+ * (`iserve-shared-types/src/schemas/Workflow/WorkflowSubSchemas.schema.ts` ->
+ * `DbEscalationLevelSchema.type.enum = Object.values(EscalationType)`).
+ * Do not "fix" it without a data migration.
+ */
 export declare enum EscalationType {
     Auto = "auto",
     Manual = "manual",
     SeniorEscalation = "seniorEsalation"
 }
+/** Unit the `period` on an escalation level is expressed in. */
 export declare enum PeriodType {
     Days = "days",
     Months = "months",
     Years = "years"
 }
+/**
+ * @deprecated Use the {@link EscalationType} enum. This permissive alias is the
+ * string-literal projection `` `${EscalationType}` `` — it accepts raw string
+ * literals (`'auto'`) and enforces nothing beyond the spelling. Kept exported
+ * only so in-flight consumer code compiles during the migration; removed in the
+ * next major.
+ *
+ * Migration: `type: 'auto'` -> `type: EscalationType.Auto`.
+ */
+export type EscalationLevelType = `${EscalationType}`;
+/**
+ * @deprecated Use the {@link PeriodType} enum. String-literal projection
+ * `` `${PeriodType}` ``; see {@link EscalationLevelType} for the rationale and
+ * removal plan.
+ *
+ * Migration: `periodType: 'days'` -> `periodType: PeriodType.Days`.
+ */
+export type EscalationLevelPeriodType = `${PeriodType}`;
 export interface EscalationLevelInterface {
-    type: EscalationType | string;
-    periodType: PeriodType | string;
+    /**
+     * Escalation mechanism. Strictly {@link EscalationType} — the DB column is
+     * constrained to `Object.values(EscalationType)`
+     * (`iserve-shared-types/src/schemas/Workflow/WorkflowSubSchemas.schema.ts:41`),
+     * so the enum is the enforced truth and raw literals are a compile error.
+     */
+    type: EscalationType;
+    /**
+     * Unit `period` is expressed in. Strictly {@link PeriodType}; same DB
+     * constraint (`WorkflowSubSchemas.schema.ts:42`).
+     */
+    periodType: PeriodType;
     members: string[];
     period: number;
 }

package/dist/interfaces/Backend/EscalationLevel.interface.js

@@ -1,15 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PeriodType = exports.EscalationType = void 0;
-var EscalationType;
+/**
+ * Escalation mechanism for a workflow step.
+ *
+ * NOTE: `SeniorEscalation = 'seniorEsalation'` is misspelled in its VALUE. The
+ * spelling is preserved verbatim because it is what is persisted in the database
+ * (`iserve-shared-types/src/schemas/Workflow/WorkflowSubSchemas.schema.ts` ->
+ * `DbEscalationLevelSchema.type.enum = Object.values(EscalationType)`).
+ * Do not "fix" it without a data migration.
+ */
+export var EscalationType;
 (function (EscalationType) {
     EscalationType["Auto"] = "auto";
     EscalationType["Manual"] = "manual";
     EscalationType["SeniorEscalation"] = "seniorEsalation";
-})(EscalationType || (exports.EscalationType = EscalationType = {}));
-var PeriodType;
+})(EscalationType || (EscalationType = {}));
+/** Unit the `period` on an escalation level is expressed in. */
+export var PeriodType;
 (function (PeriodType) {
     PeriodType["Days"] = "days";
     PeriodType["Months"] = "months";
     PeriodType["Years"] = "years";
-})(PeriodType || (exports.PeriodType = PeriodType = {}));
+})(PeriodType || (PeriodType = {}));

package/dist/interfaces/Backend/FollowUpOperation.interface.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/interfaces/Backend/index.d.ts

@@ -1,3 +1 @@
-export type { BackendApiRequiredParams, BackEndFollowUpOperationInterface, } from './FollowUpOperation.interface';
-export { EscalationType, PeriodType, } from './EscalationLevel.interface';
-export type { EscalationLevelInterface } from './EscalationLevel.interface';
+export type { BackendApiRequiredParams, BackEndFollowUpOperationInterface, } from './FollowUpOperation.interface.js';

package/dist/interfaces/Backend/index.js

@@ -1,6 +1,32 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PeriodType = exports.EscalationType = void 0;
-var EscalationLevel_interface_1 = require("./EscalationLevel.interface");
-Object.defineProperty(exports, "EscalationType", { enumerable: true, get: function () { return EscalationLevel_interface_1.EscalationType; } });
-Object.defineProperty(exports, "PeriodType", { enumerable: true, get: function () { return EscalationLevel_interface_1.PeriodType; } });
+export {};
+/*
+ * ESCALATION — WITHDRAWN, PENDING A PROPER FEATURE.
+ *
+ * Nothing is re-exported from `./EscalationLevel.interface` while the feature is
+ * out. The declarations in that file are kept (also commented) so reintroduction
+ * is a diff rather than a rewrite.
+ *
+ * The feature never worked end to end:
+ *   - this package and the Mongoose column spelled the field `escalationRulee`;
+ *   - the engine reads `escalationRules`
+ *     (`osproc-be/src/services/workflow.ts:748,934,966,984`);
+ *   - the only editor control that could author either spelling is commented out
+ *     (`processStepEditorConfig.ts:480-497`).
+ * There was no producer, and the reader dereferenced a key nothing writes —
+ * `undefined` every time, so no auto-escalation was ever scheduled.
+ *
+ * Withdrawing it removes a public surface that promised behaviour the system
+ * could not deliver. `ENGINE_INTEGRITY_NOTES` records the full history.
+ *
+ * export {
+ *   EscalationType,
+ *   PeriodType,
+ * } from './EscalationLevel.interface.js';
+ * export type { EscalationLevelInterface } from './EscalationLevel.interface.js';
+ *
+ * // @deprecated Use the EscalationType / PeriodType enums.
+ * export type {
+ *   EscalationLevelType,
+ *   EscalationLevelPeriodType,
+ * } from './EscalationLevel.interface.js';
+ */

package/dist/interfaces/Config/ElementEditorConfig.interface.d.ts

@@ -1,5 +1,5 @@
 import type { ElementEditorConfigSectionInterface } from 'ngx-t-forms-types';
-import type { ElementEditorStepConfigSectionInterface } from './ElementEditorConfigSection.interface';
+import type { ElementEditorStepConfigSectionInterface } from './ElementEditorConfigSection.interface.js';
 export declare enum ConfigTypes {
     BasicDetail = "basicDetail",
     EditProcessStep = "editProcessStep"

package/dist/interfaces/Config/ElementEditorConfig.interface.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigTypes = void 0;
-var ConfigTypes;
+export var ConfigTypes;
 (function (ConfigTypes) {
     ConfigTypes["BasicDetail"] = "basicDetail";
     ConfigTypes["EditProcessStep"] = "editProcessStep";
-})(ConfigTypes || (exports.ConfigTypes = ConfigTypes = {}));
+})(ConfigTypes || (ConfigTypes = {}));

package/dist/interfaces/Config/ElementEditorConfigSection.interface.d.ts

@@ -1,11 +1,55 @@
 import type { BlurHandleTypes, ConfigurationValidTestInterface, ElementEditorTypes, IGetTreeResponse, IPostmanCollectionConfig, IWorkflowOption, ValidationError } from 'ngx-t-forms-types';
-import type { ProcessStep } from '../ProcessStep/ProcessStep.interface';
+import type { ProcessStep } from '../ProcessStep/ProcessStep.interface.js';
+import type { HttpRequestOptions } from './NgxTWorkflowsConfig.interface.js';
+/**
+ * Recursion budget for {@link DeepBindPath}. `_PathDepth[D]` is `D - 1`, and
+ * `_PathDepth[0]` is `never`, which terminates the recursion.
+ */
+type _PathDepth = [never, 0, 1, 2, 3];
+/**
+ * Every valid property path into `T`, as a tuple of keys.
+ *
+ * `[K]` binds the whole field; `[K, ...rest]` descends into a nested object.
+ * Arrays, `Date`s and functions TERMINATE a path — the editor binds those
+ * wholesale (`deepBind: ['outputs']`), never into their members, and descending
+ * into them would explode the union with things like `['duration','toISOString']`.
+ *
+ * WHY: `deepBind` was `[keyof ProcessStep, ...string[]]`, which type-checked only
+ * the FIRST segment. That is how `deepBind: ['bulkEmail', ' emailBodyFormKey']`
+ * (leading space) survived in the library's editor config as a silent no-op
+ * write. Every segment is now checked.
+ *
+ * DEPTH: default 3, i.e. paths of up to three segments. Every real `deepBind` in
+ * `ngx-t-workflows` is one or two segments, and `ProcessStep`'s deepest nested
+ * object (`bulkEmail`, `duration`, `position`) is one level of descent, so 3 is
+ * already one level of headroom. Raise it only with a compile-time measurement.
+ *
+ * INDEX SIGNATURES: a field typed `Record<string, …>` degrades this to accepting
+ * any string for that branch, because `Extract<keyof T, string>` yields `string`.
+ * `ProcessStep` has none left — `bulkEmail` was the only one and is now the
+ * concrete `BulkEmailConfig`. Do not reintroduce one without re-checking here.
+ */
+export type DeepBindPath<T, D extends number = 3> = [D] extends [never] ? never : T extends object ? {
+    [K in Extract<keyof T, string>]: [K] | (NonNullable<T[K]> extends readonly unknown[] ? never : NonNullable<T[K]> extends Date ? never : NonNullable<T[K]> extends (...args: never[]) => unknown ? never : NonNullable<T[K]> extends object ? [K, ...DeepBindPath<NonNullable<T[K]>, _PathDepth[D]>] : never);
+}[Extract<keyof T, string>] : never;
+/**
+ * @deprecated Escape hatch for a `deepBind` whose path is genuinely dynamic and
+ * therefore not expressible as a {@link DeepBindPath}. Prefer fixing the path.
+ * Nothing in `ngx-t-workflows` needs this today; it exists so a single
+ * unrepresentable binding never forces `deepBind` back to `...string[]` for
+ * everyone. Removed in the next major.
+ */
+export type LooseDeepBindPath = [string, ...string[]];
 export interface ElementEditorInnerSectionStepElementInterface {
     id: string;
     name: keyof ProcessStep | 'default';
     hint?: string;
     editType: ElementEditorTypes;
-    deepBind: [keyof ProcessStep, ...string[]];
+    /**
+     * Property path this editor element writes to, verified segment-by-segment.
+     * @see DeepBindPath
+     */
+    deepBind: DeepBindPath<ProcessStep>;
     limitTo?: number;
     additionalTest?: ConfigurationValidTestInterface[];
     disabled?: ConfigurationValidTestInterface[];
@@ -25,9 +69,27 @@ export interface ElementEditorInnerSectionStepElementInterface {
     min?: number;
     max?: number;
     step?: number;
-    format?: (value: unknown) => number;
+    /**
+     * Value formatter for the bound editor element.
+     *
+     * Declared with METHOD shorthand (`format?(value): number`), not property-arrow
+     * shorthand (`format?: (value) => number`). This is load-bearing: `strictFunctionTypes`
+     * checks function-typed *properties* contravariantly but leaves *methods* bivariant.
+     * The consuming library supplies concrete narrow formatters — `(value: string) => number`,
+     * `(value: number) => number` — which are NOT assignable to a contravariant
+     * `(value: unknown) => number` property. Method form keeps `unknown` (per RULES.md
+     * "no `any`") while still accepting every existing formatter, so migrating the
+     * library to this package does not require rewriting its formatter callbacks.
+     */
+    format?(value: unknown): number;
     postmanCollectionConfig?: IPostmanCollectionConfig;
-    httpGetDataFunction?: (url: string, options?: RequestInit) => import('rxjs').Observable<unknown>;
+    /**
+     * Host-provided HTTP GET. `options` is an Angular `HttpClient` option bag, NOT a
+     * fetch `RequestInit` — see {@link HttpRequestOptions}. Method shorthand for the
+     * same bivariance reason as {@link ElementEditorInnerSectionStepElementInterface.format}:
+     * the library's call sites are declared `(url: string, options: any) => Observable<any>`.
+     */
+    httpGetDataFunction?(url: string, options?: HttpRequestOptions): import('rxjs').Observable<unknown>;
     getWorkflowOptions?: import('rxjs').Observable<IWorkflowOption[]> | undefined;
     getMscoaTree?: import('rxjs').Observable<IGetTreeResponse> | undefined;
 }
@@ -38,3 +100,4 @@ export interface ElementEditorStepConfigSectionInterface {
     additionalTest?: ConfigurationValidTestInterface[];
     elements: ElementEditorInnerSectionStepElementInterface[];
 }
+export {};

package/dist/interfaces/Config/ElementEditorConfigSection.interface.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/interfaces/Config/ExtendedDbForm.interface.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/interfaces/Config/NgxTWorkflowsConfig.interface.d.ts

@@ -1,10 +1,57 @@
 import type { Observable } from 'rxjs';
-import type { DatabaseFormInterface } from 'ngx-t-forms-types';
-import type { WorkflowModel } from '../Workflow/WorkflowModel.interface';
+import type { DatabaseFormInterface, FormColumnInputs } from 'ngx-t-forms-types';
+import type { DbWorkflowModel } from '../Workflow/WorkflowModel.interface.js';
+import type { INodeMembers } from '../Diagram/WorkflowDiagram.interface.js';
+import type { ExtendedDbFormInterface } from './ExtendedDbForm.interface.js';
+/**
+ * Options bag forwarded to the host's HTTP layer.
+ *
+ * Deliberately NOT `RequestInit`: every real caller is an Angular application
+ * that forwards these straight to `HttpClient.get`/`HttpClient.post`, whose
+ * option bag (`headers`, `params`, `withCredentials`, `observe`, `responseType`,
+ * …) is unrelated to the `fetch` API. Typing it as `RequestInit` made the host's
+ * genuine call sites fail to compile. Kept permissive on purpose — this package
+ * must not take a dependency on `@angular/common/http`.
+ */
+export type HttpRequestOptions = Record<string, unknown>;
+/**
+ * Typed reference data the canvas joins against to hydrate steps into nodes and
+ * populate pickers.
+ *
+ * Replaces the previous stringly-typed `dataIntegration(): Observable<Record<string, unknown>>`
+ * bag, which was the root cause of a production defect (the `ALL_`/`All_` forms-key
+ * casing incident). Do not reintroduce the untyped variant.
+ *
+ * Shape is copied verbatim from the Angular library's
+ * `src/lib/interfaces/NgxTWorkflowsConfig.ts`, which is the authority here.
+ */
+export interface WorkflowReferenceData {
+    /** Members available for assignment to steps. */
+    members: INodeMembers[];
+    /** Forms available for attachment / micro-flow resolution. */
+    forms: ExtendedDbFormInterface[];
+    /** All possible form inputs, used by decision gates and label pickers. */
+    inputs: FormColumnInputs[];
+    /** Optional organisation financial-cycle window. */
+    currentFinancialCycle?: {
+        start?: string;
+        end?: string;
+    };
+}
 export interface NgxTWorkflowsConfig {
     runPipeLine: (pipeline: unknown[], workflowId: string) => Observable<unknown>;
-    postToServer: (url: string, data: unknown, options?: RequestInit) => Observable<unknown>;
-    dataIntegration: () => Observable<Record<string, unknown>>;
-    saveWorkflow: (workflow: WorkflowModel) => Observable<WorkflowModel | undefined>;
+    postToServer: (url: string, data: unknown, options?: HttpRequestOptions) => Observable<unknown>;
+    /**
+     * Typed reference snapshot. The host applies its own `shareReplay`/caching.
+     *
+     * @see WorkflowReferenceData
+     */
+    referenceData: () => Observable<WorkflowReferenceData>;
+    /**
+     * `DbWorkflowModel`, not the lean `WorkflowModel`: the host's implementation
+     * branches on `workflow._id` to decide create-vs-update
+     * (`iserve-procurement/src/app/app-configs/ngx-t-workflows-config.service.ts`).
+     */
+    saveWorkflow: (workflow: DbWorkflowModel) => Observable<DbWorkflowModel | undefined>;
     cloneForm: (formId: string, title: string, baseControlNameAdapter: string) => Observable<DatabaseFormInterface>;
 }

package/dist/interfaces/Config/NgxTWorkflowsConfig.interface.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};