ngx-t-forms-types 0.0.24 → 0.0.26

package/dist/interfaces/FormBuilder/elementEditor.d.ts

@@ -36,7 +36,9 @@ export declare enum ElementEditorTypes {
     DecisionGateSettings = "decisionGateSettings",
     RecordListManager = "recordListManager",
     MapMatOptionsKeys = "mapMatOptionsKeys",
-    FormPayloadProjection = "formPayloadProjection"
+    FormPayloadProjection = "formPayloadProjection",
+    /** Opt-in JSON body template ({@link PayloadTemplate}) for a POST value/options fetch. */
+    PayloadTemplate = "payloadTemplate"
 }
 export interface ElementEditorConfigInterface {
     editorSections: Array<ElementEditorConfigSectionInterface>;

package/dist/interfaces/FormBuilder/elementEditor.js

@@ -31,6 +31,8 @@ export var ElementEditorTypes;
     ElementEditorTypes["RecordListManager"] = "recordListManager";
     ElementEditorTypes["MapMatOptionsKeys"] = "mapMatOptionsKeys";
     ElementEditorTypes["FormPayloadProjection"] = "formPayloadProjection";
+    /** Opt-in JSON body template ({@link PayloadTemplate}) for a POST value/options fetch. */
+    ElementEditorTypes["PayloadTemplate"] = "payloadTemplate";
 })(ElementEditorTypes || (ElementEditorTypes = {}));
 // interface TStringExpressionValidationTest{
 //   expression: string;

package/dist/interfaces/FormBuilder/inputConfig/ElementEditConfig.js

@@ -10,6 +10,159 @@ import { RichTextEditorType } from "../../formInput/RichTextEditorInput.js";
 import { LabelPosition } from "../../formInput/ToggleInputInterface.js";
 import { AllFormInputPrimaryKeys, SpecialElementKeys } from "../FormInputKeys.js";
 import { BlurHandleTypes, ElementEditorTypes } from "../elementEditor.js";
+import { DOCUMENT_PICKER_FILTER_OPERATORS, DOCUMENT_PICKER_FILTER_VALUE_SOURCES, DOCUMENT_PICKER_FILTER_VALUE_TYPES } from "../../formInput/WorkflowDocumentPicker.js";
+/** Human-facing names for the document-picker filter operators. */
+const DOCUMENT_PICKER_FILTER_OPERATOR_LABELS = {
+    eq: 'Is',
+    ne: 'Is not',
+    in: 'Is any of',
+    nin: 'Is none of',
+    gt: 'Greater than',
+    gte: 'Greater than or equal to',
+    lt: 'Less than',
+    lte: 'Less than or equal to',
+    regex: 'Contains',
+    exists: 'Has a value',
+};
+/** Human-facing names for the two mutually exclusive filter value sources. */
+const DOCUMENT_PICKER_FILTER_VALUE_SOURCE_LABELS = {
+    fixed: 'Fixed value',
+    input: 'From another input',
+};
+/**
+ * Shows a row only while the filter is NOT input-bound.
+ *
+ * Deliberately written as `!== input` rather than `=== fixed`: `valueSource` is
+ * absent on every filter saved before the switch existed and on a brand-new
+ * record, and `testAgainstItem` resolves an absent deep-bound key to `undefined`.
+ * `undefined !== 'input'` is true, so the fixed-value rows stay visible for those
+ * records instead of silently becoming uneditable.
+ */
+const DOCUMENT_PICKER_FILTER_IS_FIXED_TEST = `valueSource !== input`;
+/** Shows a row only once the administrator has explicitly chosen the input source. */
+const DOCUMENT_PICKER_FILTER_IS_INPUT_TEST = `valueSource === input`;
+/**
+ * Per-record editor for one preset filter (`IDocumentPickerFilter`) inside the
+ * document picker's "Preset filters" list.
+ */
+const DOCUMENT_PICKER_FILTER_EDITOR = () => [
+    {
+        label: 'Filter',
+        id: "0f0a5c1e-1d3b-4a76-9e2c-6b8f4a91d0c7",
+        elements: [
+            {
+                name: SpecialElementKeys.Default,
+                deepBind: ['path'],
+                editType: ElementEditorTypes.Input,
+                label: 'Field',
+                required: true,
+                placeholder: 'form.status',
+                hint: `The document field to filter on. Form fields are written as form.<field name>; reference, status and archive live on the document itself.`,
+                id: "5c9d2f70-8e41-4b0a-9d63-2a7c5e18b4f2"
+            },
+            {
+                name: SpecialElementKeys.Default,
+                deepBind: ['op'],
+                editType: ElementEditorTypes.ChipSelect,
+                label: 'Operator',
+                defaultValue: 'eq',
+                options: DOCUMENT_PICKER_FILTER_OPERATORS.map((op) => ({
+                    label: DOCUMENT_PICKER_FILTER_OPERATOR_LABELS[op],
+                    value: op,
+                })),
+                id: "b1e74a63-0c95-4d8e-8f27-3d6a9c02e5b8"
+            },
+            {
+                name: SpecialElementKeys.Default,
+                deepBind: ['valueSource'],
+                editType: ElementEditorTypes.ChipSelect,
+                label: 'Where the value comes from',
+                hint: `A filter compares against one value only. Pick a fixed value you type here, or follow an input the user fills in earlier on this form.`,
+                options: DOCUMENT_PICKER_FILTER_VALUE_SOURCES.map((source) => ({
+                    label: DOCUMENT_PICKER_FILTER_VALUE_SOURCE_LABELS[source],
+                    value: source,
+                })),
+                // NO defaultValue. The nested editor emits `defaultValue` on init when the
+                // bound key is absent, which would stamp `fixed` onto every filter saved
+                // before this switch existed — silently converting an input-bound filter
+                // the moment an administrator merely opened it. The two `additionalTest`
+                // expressions below tolerate an absent `valueSource` on their own instead.
+                //
+                // `clearOnChange` drops the input-bound side, so switching to a fixed value
+                // can never leave a live binding behind. It is deliberately one-sided: the
+                // fixed `value` is NOT listed, because a leftover `value` under the input
+                // source is hidden here and ignored by `buildDocumentFilter`, whereas
+                // clearing it would throw away typed work every time the source is toggled.
+                // RecordListManager applies these paths only when `valueSource` moves away
+                // from a value the record already held, so opening a filter saved before
+                // this switch existed never clears anything.
+                clearOnChange: [
+                    ['fromInputId'],
+                    ['omitWhenEmpty'],
+                ],
+                id: "2f6b8d04-91c7-4a5e-b3f0-7d2e6a148c15",
+            },
+            {
+                name: SpecialElementKeys.Default,
+                deepBind: ['fromInputId'],
+                editType: ElementEditorTypes.FormInputSelector,
+                label: 'Take the value from another input',
+                hint: `The filter follows that input's current value — use it to show only transactions matching something the user picked earlier in this form.`,
+                additionalTest: [
+                    {
+                        expression: DOCUMENT_PICKER_FILTER_IS_INPUT_TEST,
+                        deepBind: ['valueSource'],
+                    },
+                ],
+                id: "7a3f8d21-4b60-4e19-a5c8-91d4e7f36b0a"
+            },
+            {
+                name: SpecialElementKeys.Default,
+                deepBind: ['omitWhenEmpty'],
+                editType: ElementEditorTypes.Toggle,
+                label: 'Ignore this filter when the value is empty',
+                hint: `On: the filter is skipped until that input has a value. Off: an empty value is filtered on literally.`,
+                additionalTest: [
+                    {
+                        expression: DOCUMENT_PICKER_FILTER_IS_INPUT_TEST,
+                        deepBind: ['valueSource'],
+                    },
+                ],
+                id: "9b52c7e3-6d81-40af-a7c9-4e13b805d6f2"
+            },
+            {
+                name: SpecialElementKeys.Default,
+                deepBind: ['value'],
+                editType: ElementEditorTypes.Input,
+                label: 'Fixed value',
+                hint: `For "Is any of" / "Is none of", separate values with commas.`,
+                additionalTest: [
+                    {
+                        expression: DOCUMENT_PICKER_FILTER_IS_FIXED_TEST,
+                        deepBind: ['valueSource'],
+                    },
+                ],
+                id: "e6c05b94-2f78-4a3d-b1e5-8c07f9a24d63"
+            },
+            {
+                name: SpecialElementKeys.Default,
+                deepBind: ['valueType'],
+                editType: ElementEditorTypes.ChipSelect,
+                label: 'Value type',
+                defaultValue: 'string',
+                hint: `How the fixed value is read. Pick Number or Boolean when the stored field is not text, otherwise the comparison never matches.`,
+                options: DOCUMENT_PICKER_FILTER_VALUE_TYPES.map((type) => ({ label: type, value: type })),
+                additionalTest: [
+                    {
+                        expression: DOCUMENT_PICKER_FILTER_IS_FIXED_TEST,
+                        deepBind: ['valueSource'],
+                    },
+                ],
+                id: "3d8b1e07-9a24-4c65-8f0b-52e7a6c91f4d"
+            },
+        ],
+    },
+];
 export var ElementConfig = {
     editorSections: [
         {
@@ -424,8 +577,13 @@ export var ElementConfig = {
                     name: AllFormInputPrimaryKeys.WorkflowPickerConfig,
                     deepBind: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'primaryIdentifierKey'],
                     label: "Select primary identifier key",
-                    hint: "Choose a key other than _id to serve as the primary identifier for workflow documents. Note: existing mappings will be cleared when reconfigured. After updating, reselect the workflow above.",
+                    hint: "Choose a key other than _id to identify the selected transaction. Leave it unset to use _id.",
                     editType: ElementEditorTypes.MapMatOptionsKeys,
+                    // The key tree is built from `sampleDocument`. This row must NOT clear it:
+                    // `clearOnChange` runs on every emission from this editor, so clearing the
+                    // sample here wiped the tree the moment a key was picked — the options
+                    // appeared, then vanished on first click. The sample is owned by the
+                    // workflow selection above and is refreshed whenever the workflow changes.
                     fetchOptions: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'sampleDocument'],
                     additionalTest: [
                         {
@@ -433,98 +591,43 @@ export var ElementConfig = {
                             testType: 'exists',
                         }
                     ],
-                    clearOnChange: [
-                        [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'sampleDocument'],
-                    ],
                     id: "c9396a58-1d72-4ef9-8eff-5a28e8f738a1"
                 },
                 {
                     name: AllFormInputPrimaryKeys.WorkflowPickerConfig,
-                    deepBind: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'documentSourceType'],
-                    hint: `Choose the source type for document options: 'Postman API' fetches from an external API, 'Data Pipeline' pulls from MongoDB.`,
+                    deepBind: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'stepFilter', 'stepIds'],
                     editType: ElementEditorTypes.ChipSelect,
-                    label: 'Document options source type',
-                    defaultValue: 'default',
-                    clearOnChange: [
-                        [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'documentsSource'],
-                    ],
-                    options: [
-                        {
-                            label: 'Default',
-                            value: 'default'
-                        },
-                        { label: 'Postman API', value: DataSources.Api },
-                        // { label: 'Data Pipeline', value: DataSources.MongoDb },
-                    ],
-                    id: "f04cc297-9b22-403a-afe4-4fb2e84fa503"
-                },
-                {
-                    name: AllFormInputPrimaryKeys.WorkflowPickerConfig,
-                    deepBind: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'documentsSource'],
-                    editType: ElementEditorTypes.ApiCall,
+                    multipleSelection: true,
+                    label: 'Limit to workflow steps',
+                    hint: `Optional. Restricts the picker to transactions currently sitting on the selected steps. Leave empty to let the user choose a step while browsing.`,
+                    fetchOptions: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'availableSteps'],
                     additionalTest: [
                         {
-                            expression: `documentSourceType === ${DataSources.Api}`,
-                            deepBind: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'documentSourceType'],
+                            testType: 'exists',
+                            deepBind: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'workflowId'],
                         },
                     ],
-                    clearOnChange: [
-                        [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'documentsSource'],
-                    ],
-                    hint: `Select an API endpoint from your Postman collection to fetch document options. Configure headers, payload format, and response mapping as needed.`,
-                    label: 'Select doc option API endpoint',
-                    id: "ecb1ea0e-3d2d-447f-a68e-48f1378fc0a7"
+                    id: "f04cc297-9b22-403a-afe4-4fb2e84fa503"
                 },
                 {
                     name: AllFormInputPrimaryKeys.WorkflowPickerConfig,
-                    deepBind: [
-                        AllFormInputPrimaryKeys.WorkflowPickerConfig, 'documentsSource',
-                        'backEndConfig',
-                        'minimumInputRequired',
+                    deepBind: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'presetFilters'],
+                    editType: ElementEditorTypes.RecordListManager,
+                    label: 'Preset filters',
+                    hint: `Optional. Narrows the transactions a user can pick from, before they search. Each filter targets a document field: form fields are written as form.<field name>, and the document itself exposes reference, status and archive.`,
+                    secondaryElementEditorConfig: DOCUMENT_PICKER_FILTER_EDITOR(),
+                    options: [
+                        { label: 'Field', value: 'path' },
+                        { label: 'Operator', value: 'op' },
+                        { label: 'Value', value: 'value' },
                     ],
                     additionalTest: [
                         {
                             testType: 'exists',
-                            deepBind: [
-                                AllFormInputPrimaryKeys.WorkflowPickerConfig, 'documentsSource',
-                                'backEndConfig',
-                                'minimumInputRequired',
-                            ],
-                        }
-                    ],
-                    hint: `These are payload fields that are required to be filled in order to fetch data from the selected source`,
-                    editType: ElementEditorTypes.RequiredInputs,
-                    label: 'Set up required inputs',
-                    id: "c1e79e55-18b7-4c4c-8b16-5f792f34e0be"
-                },
-                {
-                    name: AllFormInputPrimaryKeys.WorkflowPickerConfig,
-                    deepBind: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'documentsSource', 'valueAccessRules'],
-                    hint: `Map the fetched data to the input value. This is useful when the fetched data is an object and you want to map a specific field to the input value.It also allow data transformation before setting the value`,
-                    fetchOptions: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'documentsSource', '_id'],
-                    additionalTest: [
-                        {
-                            expression: `documentSourceType === ${DataSources.Api}`,
-                            deepBind: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'documentSourceType'],
-                        },
-                    ],
-                    editType: ElementEditorTypes.ApiValueAccessRules,
-                    label: 'Map value to fetched data',
-                    id: "9ccb074d-00be-4c90-8989-2309e9faed10"
-                },
-                {
-                    name: AllFormInputPrimaryKeys.WorkflowPickerConfig,
-                    deepBind: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'documentsSource'],
-                    additionalTest: [
-                        {
-                            expression: "documentSourceType === mongoPipeline",
-                            deepBind: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'documentSourceType'],
+                            deepBind: [AllFormInputPrimaryKeys.WorkflowPickerConfig, 'workflowId'],
                         },
                     ],
-                    editType: ElementEditorTypes.MongoPipelineBuilder,
-                    label: 'Configure MongoDB pipeline',
-                    hint: `Create a MongoDB aggregation pipeline to fetch document options from your database.`,
-                    id: "1b826f36-08ad-46b5-86ea-c1c48fd90f51"
+                    id: "ecb1ea0e-3d2d-447f-a68e-48f1378fc0a7"
                 },
                 //********************** */
                 {
@@ -745,6 +848,34 @@ export var ElementConfig = {
                     label: 'Configure MongoDB pipeline',
                     id: "7b2989ae-2f54-4849-93d0-aff56ac12ef2"
                 },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: ['matOptions', 'fetch', 'value', 'backEndConfig', 'requestBodyMode'],
+                    additionalTest: [
+                        {
+                            // Only once an API endpoint is configured for the value.
+                            testType: 'exists',
+                            deepBind: ['matOptions', 'fetch', 'value'],
+                        },
+                    ],
+                    editType: ElementEditorTypes.ChipSelect,
+                    label: 'Request body configuration',
+                    hint: 'Choose how the POST body is built: map required inputs, or author a JSON payload template. Only one is used.',
+                    defaultValue: 'mappedInputs',
+                    // NO clearOnChange. Both configurations are kept side by side —
+                    // `requestBodyMode` alone decides which one the runtime uses, and the
+                    // two editors below are shown/hidden by their `additionalTest`. Clearing
+                    // here destroyed the author's work on every mode toggle, and — because
+                    // the editor emits `defaultValue` on init when the bound key is absent —
+                    // wiped `minimumInputRequired` merely on OPENING an existing POST fetch.
+                    // A fetch left with no `minimumInputRequired` key then crashed
+                    // `getAllFunctionTypes`, silently disabling the whole input.
+                    options: [
+                        { label: 'Map inputs', value: 'mappedInputs' },
+                        { label: 'JSON template', value: 'template' },
+                    ],
+                    id: "a1d2f3e4-5b6c-4d7e-8f90-1a2b3c4d5e6f"
+                },
                 {
                     name: SpecialElementKeys.Default,
                     deepBind: [
@@ -764,13 +895,39 @@ export var ElementConfig = {
                                 'backEndConfig',
                                 'minimumInputRequired',
                             ],
-                        }
+                        },
+                        {
+                            // Hidden while the author is using a payload template instead.
+                            expression: 'requestBodyMode !== template',
+                            deepBind: ['matOptions', 'fetch', 'value', 'backEndConfig', 'requestBodyMode'],
+                        },
                     ],
                     hint: `These are payload fields that are required to be filled in order to fetch data from the selected source`,
                     editType: ElementEditorTypes.RequiredInputs,
                     label: 'Set up required inputs',
                     id: "2d0f1e18-897b-4c28-97bc-3078be09f8ee"
                 },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: [
+                        'matOptions',
+                        'fetch',
+                        'value',
+                        'backEndConfig',
+                        'payloadTemplate',
+                    ],
+                    additionalTest: [
+                        {
+                            // Shown only when the author has chosen template mode.
+                            expression: 'requestBodyMode === template',
+                            deepBind: ['matOptions', 'fetch', 'value', 'backEndConfig', 'requestBodyMode'],
+                        },
+                    ],
+                    hint: `Author the POST request body as JSON. Type $ to insert a field as {{inputId}}; every other literal is a fixed default. This supersedes the required-input mapping.`,
+                    editType: ElementEditorTypes.PayloadTemplate,
+                    label: 'Payload template',
+                    id: "b3f6a1c2-7d8e-4a90-8c11-2e5f0a9b7c34"
+                },
                 {
                     name: SpecialElementKeys.Default,
                     deepBind: ['matOptions', 'fetch', 'value', 'valueAccessRules'],
@@ -878,6 +1035,28 @@ export var ElementConfig = {
                     label: 'Select API to fetch data from',
                     id: "df9e2a34-7bf5-411e-a265-14ca4f85166d"
                 },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: ['matOptions', 'fetch', 'options', 'backEndConfig', 'requestBodyMode'],
+                    additionalTest: [
+                        {
+                            testType: 'exists',
+                            deepBind: ['matOptions', 'fetch', 'options'],
+                        },
+                    ],
+                    editType: ElementEditorTypes.ChipSelect,
+                    label: 'Request body configuration',
+                    hint: 'Choose how the POST body is built: map required inputs, or author a JSON payload template. Only one is used.',
+                    defaultValue: 'mappedInputs',
+                    // NO clearOnChange — see the value-slot twin above. This one cleared
+                    // ['matOptions','fetch','options'], i.e. the ENTIRE options fetch config
+                    // (endpoint, method, source and all), on the editor's init emit.
+                    options: [
+                        { label: 'Map required inputs', value: 'mappedInputs' },
+                        { label: 'Payload template (JSON)', value: 'template' },
+                    ],
+                    id: "e2c4a6b8-1d3f-4a5b-9c7e-0f1a2b3c4d5e"
+                },
                 {
                     name: SpecialElementKeys.Default,
                     deepBind: [
@@ -897,12 +1076,36 @@ export var ElementConfig = {
                                 'backEndConfig',
                                 'minimumInputRequired',
                             ],
-                        }
+                        },
+                        {
+                            expression: 'requestBodyMode !== template',
+                            deepBind: ['matOptions', 'fetch', 'options', 'backEndConfig', 'requestBodyMode'],
+                        },
                     ],
                     editType: ElementEditorTypes.RequiredInputs,
                     label: 'Set up required inputs',
                     id: "ce8f3b42-340d-4f3e-8d6a-13c93251173f"
                 },
+                {
+                    name: SpecialElementKeys.Default,
+                    deepBind: [
+                        'matOptions',
+                        'fetch',
+                        'options',
+                        'backEndConfig',
+                        'payloadTemplate',
+                    ],
+                    additionalTest: [
+                        {
+                            expression: 'requestBodyMode === template',
+                            deepBind: ['matOptions', 'fetch', 'options', 'backEndConfig', 'requestBodyMode'],
+                        },
+                    ],
+                    hint: `Author the POST request body as JSON. Type $ to insert a field as {{inputId}}; every other literal is a fixed default. This supersedes the required-input mapping.`,
+                    editType: ElementEditorTypes.PayloadTemplate,
+                    label: 'Payload template',
+                    id: "c7a2e4d1-9b0f-4e63-a5d8-71f3b2c6e089"
+                },
                 {
                     name: SpecialElementKeys.Default,
                     deepBind: ['matOptions', 'fetch', 'options', 'valueAccessRules'],

package/dist/interfaces/FormBuilder/workflowSelectionConfig.d.ts

@@ -8,8 +8,35 @@ export interface IWorkflowOption {
     isDocument: boolean;
     id: string;
 }
+/**
+ * A column of the workflow's transaction list, as configured on the workflow itself.
+ *
+ * `formControlName` names the form field; `path` is where that field actually lives
+ * in the stored document and is what sorting and searching must address — a form
+ * field sorted by its bare control name silently sorts on a non-existent root field.
+ */
 export interface IWorkflowDocListCols {
     label: string;
     formControlName: string;
     type?: DocumentLitsLabelConfigInterfaceValueType | InputDataTypes | undefined | InputPipeTypes;
+    /**
+     * Where the column's value actually lives in the stored document — `form.amount`
+     * for a form field, or a root field such as `reference`. Sorting and searching
+     * address this path: a form field addressed by its bare control name resolves to
+     * a non-existent root field and silently returns unordered, unsearched results.
+     */
+    path: string;
+    /** `true` when the workflow marks the column hidden from its transaction list. */
+    hidden: boolean;
+}
+/** A step of a workflow, as offered to a user filtering transactions by step. */
+export interface IWorkflowStepOption {
+    /** Matches the transaction's `currentStepID`. */
+    stepId: string;
+    /** Human-facing step name. */
+    label: string;
+    /** Zero-based position in the workflow's process tree. */
+    index: number;
+    /** Step kind, e.g. `initiate`, `review`, `edit`. */
+    stepType?: string;
 }

package/dist/interfaces/environment/IStoreFunctions.d.ts

@@ -4,7 +4,8 @@ import { IWorkflowOption } from "../FormBuilder/index.js";
 import { AccountingBasis, AdjResponseReviewColumnMapping, IGetTreeResponse, ScoaSegmentValue, WorkflowAdjudicationScoreSheetValue } from "../formInput/index.js";
 import { FormListSection } from "../Form/IFormsInitStateInterface.js";
 import { IUserSignature, PointGroup } from "../formInput/userSignature.js";
-import { IWorkflowDocListCols } from "../FormBuilder/workflowSelectionConfig.js";
+import { IWorkflowDocListCols, IWorkflowStepOption } from "../FormBuilder/workflowSelectionConfig.js";
+import { IDocumentPage, IDocumentQueryRequest } from "../formInput/WorkflowDocumentPicker.js";
 import { IFinancialCycles } from "./environment.js";
 export interface DialogConfig {
     title: string;
@@ -68,14 +69,28 @@ export interface IStoreFunctions {
         results: any;
         message: string;
     }>;
-    getWorkflowDocuments: (workflowId: string, page: number, itemsPerPage: number, sort: Record<string, -1 | 1>, searchKey: string | undefined, filter?: Record<string, any>) => Observable<{
-        footerConfig: {
-            totalPages: number;
-            totalItems: number;
-            itemsPerPage: number;
-        };
-        formValues: Record<string, unknown>[];
-    }>;
+    /**
+     * The single query used by every document picker. One request carries paging,
+     * sorting, filtering and search, and one page comes back.
+     *
+     * Paging is keyset-based: omit `cursor` for the first page, then pass the
+     * previous page's `nextCursor`. `sort` must stay identical for the life of a
+     * cursor sequence — a changed sort invalidates outstanding cursors, so reset
+     * paging whenever the sort, filter or search term changes.
+     *
+     * @example
+     *   queryDocuments({
+     *     workflowId,
+     *     itemsPerPage: 10,
+     *     sort: { updatedAt: -1 },
+     *     filter: { archive: false, currentStep: stepId },
+     *     searchKey: 'chairs',
+     *     schema: { reference: 'string', 'form.description': 'string' },
+     *   })
+     */
+    queryDocuments: (request: IDocumentQueryRequest) => Observable<IDocumentPage>;
+    /** Steps of a workflow, in process-tree order, for the picker's step filter. */
+    getWorkflowSteps: (workflowId: string) => Observable<IWorkflowStepOption[]>;
     fileUpload: FileUploadFn;
     formSubmittedSuccessfully: (formId: string) => void;
     getUserSignature: () => Observable<IUserSignature>;

package/dist/interfaces/formInput/APIDataFetchingConfigurationInterface.d.ts

@@ -12,6 +12,59 @@ export interface DataFetchingBaseConfig {
     source: DataSources;
     projectFormData?: string;
 }
+/**
+ * A single node in a {@link PayloadTemplate}.
+ *
+ * - Literals (`string`/`number`/`boolean`/`null`) are sent verbatim — a plain
+ *   literal is a **typed default**.
+ * - A string that is EXACTLY `"{{inputId}}"` is replaced by that input's live,
+ *   raw (type-preserving) value.
+ * - A string that merely CONTAINS `{{inputId}}` token(s) is interpolated to a
+ *   string (`"prefix-{{x}}"`).
+ * - Objects and arrays nest arbitrarily; object keys are literal, so Mongo-style
+ *   dotted keys such as `"form.contractType"` are preserved as authored.
+ */
+export type PayloadTemplateValue = string | number | boolean | null | PayloadTemplateValue[] | {
+    [key: string]: PayloadTemplateValue;
+};
+/**
+ * Declarative JSON body for a POST value/options fetch.
+ *
+ * When present on {@link APIDataFetchingConfigurationInterface.backEndConfig} it
+ * SUPERSEDES `minimumInputRequired` for request shaping: the resolved object is
+ * sent to the endpoint verbatim (no `data` envelope). `{{inputId}}` string
+ * tokens map to live form values; every other literal is a typed default. The
+ * fetch stays idle (fires no request) until every referenced input has a
+ * non-empty value, then re-fires whenever a mapped value changes.
+ *
+ * @example
+ *   payloadTemplate: {
+ *     workflowId: '65035743e948659eff7f6b5f',
+ *     valueKey: 'budgetCost',
+ *     reduce: 'sum',
+ *     isComplete: true,
+ *     filter: {
+ *       archive: false,
+ *       'form.contractType': '{{contractType}}',
+ *     },
+ *   }
+ */
+export type PayloadTemplate = {
+    [key: string]: PayloadTemplateValue;
+} | PayloadTemplateValue[];
+/**
+ * Which mechanism shapes a POST fetch's request body.
+ *
+ * - `'mappedInputs'` — the classic `minimumInputRequired` default/mapTo mapping
+ *   (also the effective default when unset, for backward compatibility).
+ * - `'template'` — the declarative {@link PayloadTemplate}.
+ *
+ * The two are mutually exclusive in the form builder (one editor at a time) and
+ * at runtime: a `payloadTemplate` supersedes the mapping ONLY when the mode is
+ * not explicitly `'mappedInputs'`, so switching modes never discards either
+ * configuration.
+ */
+export type RequestBodyMode = 'mappedInputs' | 'template';
 export interface APIDataFetchingConfigurationInterface extends DataFetchingBaseConfig {
     _id: string;
     name: string;
@@ -37,7 +90,38 @@ export interface APIDataFetchingConfigurationInterface extends DataFetchingBaseC
         } | boolean;
     };
     backEndConfig: {
-        minimumInputRequired: MinimumInputRequiredInterface[];
+        /**
+         * The default/mapTo mapping that shapes the POST body in `'mappedInputs'` mode.
+         *
+         * **Optional**, and genuinely absent in practice: a `'template'`-mode fetch shapes
+         * its body from {@link payloadTemplate} and needs no mapping at all, GET fetches
+         * never had one, and older persisted configs predate the key. Read it as
+         * `backEndConfig?.minimumInputRequired ?? []` — a bare
+         * `.minimumInputRequired.every(…)` once threw inside `getAllFunctionTypes`, whose
+         * `catch` then erased *every* function type for the input, silently disabling its
+         * resource, refresh button, calculation and validators.
+         */
+        minimumInputRequired?: MinimumInputRequiredInterface[];
+        /**
+         * Which request-body mechanism is active (see {@link RequestBodyMode}).
+         * Unset is treated as `'mappedInputs'` for backward compatibility. The form
+         * builder shows exactly one editor per mode; the runtime uses
+         * `payloadTemplate` only when this is not `'mappedInputs'`.
+         */
+        requestBodyMode?: RequestBodyMode;
+        /**
+         * Optional deep JSON template for the POST body (see {@link PayloadTemplate}).
+         * When present AND {@link requestBodyMode} is not `'mappedInputs'`, it
+         * supersedes `minimumInputRequired` for request shaping. Kept independently of
+         * the mapping so toggling {@link requestBodyMode} discards neither.
+         */
+        payloadTemplate?: PayloadTemplate;
+        /**
+         * The raw request body captured from the selected endpoint (e.g. a Postman
+         * collection). Persisted only to seed the template editor's default when the
+         * author switches to template mode with nothing authored yet; never sent.
+         */
+        requestBody?: PayloadTemplate;
     };
 }
 export interface MongoDbPipeLineConfigInterface extends DataFetchingBaseConfig {

package/dist/interfaces/formInput/WorkflowDocumentPicker.d.ts

@@ -1,17 +1,198 @@
 import { AllFormInputPrimaryKeys } from "../FormBuilder/FormInputKeys.js";
 import { TreeNode } from "../FormSlide/accessTree.js";
-import { APIDataFetchingConfigurationInterface, DataSources, MongoDbPipeLineConfigInterface } from "./APIDataFetchingConfigurationInterface.js";
+import { FormInputBasicOptionInterface } from "./FormInputBasicOptionInterface.js";
 import { IBasicFormInput } from "./BasicFormInputInterface.js";
 export interface IWorkflowDocumentPicker extends IBasicFormInput {
     workflowPickerConfig: IWorkflowDocumentPickerConfig;
     [AllFormInputPrimaryKeys.AllowMultipleSelection]: boolean;
 }
+/**
+ * Document-picker configuration.
+ *
+ * The only field an administrator must supply is `workflowId` — the table columns,
+ * the search schema, the sortable fields and the runtime step chooser are all
+ * derived from the selected workflow. Everything after it is optional and exists
+ * only to pin a picker to a narrower slice of transactions.
+ */
 export interface IWorkflowDocumentPickerConfig {
     workflowId: string;
     primaryIdentifierKey?: TreeNode[];
     sampleDocument?: Record<string, unknown>;
-    documentSourceType: DataSources | 'default';
-    documentsSource?: APIDataFetchingConfigurationInterface | MongoDbPipeLineConfigInterface;
+    /**
+     * Restricts the picker to transactions currently sitting on specific workflow
+     * steps. Omitted — or an empty `stepIds` — means every step is eligible and the
+     * end user gets a step chooser in the browse dialog.
+     */
+    stepFilter?: IWorkflowDocumentStepFilter;
+    /**
+     * Filters applied on top of the workflow scope before the user sees anything.
+     * Static values are baked in by the administrator; `fromFormControl` reads the
+     * value off a sibling control of the same form at query time.
+     */
+    presetFilters?: IDocumentPickerFilter[];
+    /**
+     * Step options captured when `workflowId` was chosen, so the builder can render
+     * a step multi-select without a live workflow round-trip. Refreshed whenever the
+     * workflow changes; the runtime step chooser always uses live steps, never this.
+     */
+    availableSteps?: FormInputBasicOptionInterface[];
+}
+/** Step restriction for a document picker. */
+export interface IWorkflowDocumentStepFilter {
+    /**
+     * Workflow step ids (`currentStepID` values) the picker is limited to.
+     *
+     * Optional, because the whole step restriction is: the builder writes a
+     * `stepFilter` record as soon as the administrator opens that control, and an
+     * empty or absent list means "every step is eligible" — the same thing as
+     * omitting `stepFilter` altogether. The runtime already reads it as
+     * `stepFilter?.stepIds ?? []`.
+     */
+    stepIds?: string[];
+}
+/** Comparison operators a {@link IDocumentPickerFilter} may apply. */
+export declare const DOCUMENT_PICKER_FILTER_OPERATORS: readonly ["eq", "ne", "in", "nin", "gt", "gte", "lt", "lte", "regex", "exists"];
+/** Comparison operator applied by a {@link IDocumentPickerFilter}. */
+export type DocumentPickerFilterOperator = typeof DOCUMENT_PICKER_FILTER_OPERATORS[number];
+/** How a filter's configured value is coerced before it is sent. */
+export declare const DOCUMENT_PICKER_FILTER_VALUE_TYPES: readonly ["string", "number", "boolean"];
+/** Declared type of a {@link IDocumentPickerFilter} value. */
+export type DocumentPickerFilterValueType = typeof DOCUMENT_PICKER_FILTER_VALUE_TYPES[number];
+/** Where a {@link IDocumentPickerFilter} reads its comparison value from. */
+export declare const DOCUMENT_PICKER_FILTER_VALUE_SOURCES: readonly ["fixed", "input"];
+/** Declared value source of a {@link IDocumentPickerFilter}. */
+export type DocumentPickerFilterValueSource = typeof DOCUMENT_PICKER_FILTER_VALUE_SOURCES[number];
+/**
+ * One administrator-configured filter clause.
+ *
+ * Exactly one value source is used, chosen by `valueSource`: the static `value`
+ * (`'fixed'`) or the current value of a sibling input (`'input'`, via `fromInputId`).
+ * For the `in` / `nin` operators a static value is split on commas before coercion.
+ *
+ * @example
+ *   // Only requisitions already approved
+ *   { path: 'form.status', op: 'eq', valueSource: 'fixed', value: 'approved' }
+ *
+ * @example
+ *   // Only transactions for the department chosen earlier in this form
+ *   { path: 'form.departmentId', op: 'eq', valueSource: 'input', fromInputId: '9f2c…', omitWhenEmpty: true }
+ */
+export interface IDocumentPickerFilter {
+    /**
+     * Stable identity of this clause, stamped by the builder's record-list editor the
+     * first time the filter is saved. It is the key that editor tracks a row by — for
+     * edit and for delete — so it is written to every persisted filter and has to
+     * round-trip through validation.
+     */
+    id?: string;
+    /**
+     * Document path to filter on. Form fields are addressed as `form.<name>`; the
+     * document root exposes `reference`, `status`, `currentStep` and `archive`.
+     */
+    path: string;
+    /** Comparison operator. Defaults to `eq` when omitted. */
+    op?: DocumentPickerFilterOperator;
+    /**
+     * Which of the two mutually exclusive value sources this clause uses.
+     *
+     * - `'fixed'` — use the static {@link IDocumentPickerFilter.value}, coerced by
+     *   {@link IDocumentPickerFilter.valueType}. Any `fromInputId` is ignored.
+     * - `'input'` — use the current value of {@link IDocumentPickerFilter.fromInputId}.
+     *   Any static `value` is ignored.
+     * - omitted — the source is inferred from what is set, so filters saved before
+     *   this field existed keep working: a present `fromInputId` means `'input'`,
+     *   otherwise `'fixed'`.
+     */
+    valueSource?: DocumentPickerFilterValueSource;
+    /**
+     * Static value supplied by the administrator. Used when `valueSource` is
+     * `'fixed'`, or — for filters saved before `valueSource` existed — when no
+     * `fromInputId` is set.
+     */
+    value?: unknown;
+    /** Coercion applied to the resolved value. Defaults to `string`. */
+    valueType?: DocumentPickerFilterValueType;
+    /**
+     * Id of a sibling input on the same form whose current value supplies the
+     * comparison value. The runtime form group is keyed by input id, not by
+     * form-control name. Used when `valueSource` is `'input'`, or — for filters
+     * saved before `valueSource` existed — whenever it is set.
+     */
+    fromInputId?: string;
+    /**
+     * Drops the clause entirely when the resolved value is empty, instead of matching
+     * on an empty value. Only meaningful for the input-bound source.
+     */
+    omitWhenEmpty?: boolean;
+}
+/**
+ * A single page of documents.
+ *
+ * Cursor-native: `nextCursor` drives forward navigation, and `totalItems` /
+ * `totalPages` are populated only on the first page — the request that carried no
+ * cursor — because the count scan is skipped on continuation pages. Cache the totals
+ * client-side rather than expecting them on every page.
+ */
+export interface IDocumentPage {
+    items: Record<string, unknown>[];
+    /** Effective page size applied, which may be clamped below the requested size. */
+    itemsPerPage: number;
+    /** `true` when another page exists after this one. */
+    hasMore: boolean;
+    /** Token to send back as `cursor` for the next page, or `null` at the end. */
+    nextCursor: string | null;
+    /** Total records matching the query. First page only. */
+    totalItems?: number;
+    /** Total page count for the query. First page only. */
+    totalPages?: number;
+}
+/**
+ * The one request shape every document-picker query uses.
+ *
+ * Sort and filter keys are document paths, not form-control names: root fields
+ * (`updatedAt`, `reference`, `currentStep`, `archive`) stay as they are, while form
+ * fields are addressed as `form.<name>`.
+ */
+export interface IDocumentQueryRequest {
+    workflowId: string;
+    itemsPerPage: number;
+    /** Omit for the first page; otherwise the previous page's `nextCursor`. */
+    cursor?: string;
+    /**
+     * Sort descriptor. Only the first entry is honoured, and `_id` is appended as a
+     * tiebreaker. Must stay identical across a cursor sequence — changing it
+     * invalidates every outstanding cursor, so reset paging when the sort changes.
+     */
+    sort: Record<string, 1 | -1>;
+    /**
+     * Merged step, preset and user filters. `_id: { $in: [...] }` is how a selection
+     * spanning several pages is hydrated in one request.
+     */
+    filter: Record<string, unknown>;
+    /**
+     * Free-text term. Requires {@link IDocumentQueryRequest.schema}: without it the
+     * term is silently ignored and an unfiltered page comes back.
+     */
+    searchKey?: string;
+    /** Path → type map scoping which fields `searchKey` searches. */
+    schema?: Record<string, string>;
+}
+/**
+ * The value a document picker writes to its form control — one entry per linked
+ * transaction, or a single entry when the input is not multi-select.
+ *
+ * Carries enough context to render the link without re-reading the builder config or
+ * re-fetching the document.
+ */
+export interface IDocumentReference {
+    /** Value of the picker's primary identifier key — `_id` unless configured otherwise. */
+    id: string;
+    /** Workflow the transaction belongs to. */
+    workflowId: string;
+    /** Human-facing transaction reference, e.g. `REQ-00412`. */
+    reference?: string;
+    /** Short descriptive label drawn from the workflow's first configured column. */
+    label?: string;
 }
 export declare enum workflowStepStatus {
     PENDING = "pending",

package/dist/interfaces/formInput/WorkflowDocumentPicker.js

@@ -1,4 +1,21 @@
 import { AllFormInputPrimaryKeys } from "../FormBuilder/FormInputKeys.js";
+/** Comparison operators a {@link IDocumentPickerFilter} may apply. */
+export const DOCUMENT_PICKER_FILTER_OPERATORS = [
+    'eq',
+    'ne',
+    'in',
+    'nin',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'regex',
+    'exists',
+];
+/** How a filter's configured value is coerced before it is sent. */
+export const DOCUMENT_PICKER_FILTER_VALUE_TYPES = ['string', 'number', 'boolean'];
+/** Where a {@link IDocumentPickerFilter} reads its comparison value from. */
+export const DOCUMENT_PICKER_FILTER_VALUE_SOURCES = ['fixed', 'input'];
 export var workflowStepStatus;
 (function (workflowStepStatus) {
     workflowStepStatus["PENDING"] = "pending";

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

@@ -1,7 +1,7 @@
 import { IFolderItem, IPostmanCollection } from "../FormBuilder/postmanCollection.js";
-import { IWorkflowDocListCols } from "../FormBuilder/workflowSelectionConfig.js";
+import { IWorkflowDocListCols, IWorkflowStepOption } from "../FormBuilder/workflowSelectionConfig.js";
 import { TreeNode } from "../FormSlide/accessTree.js";
-import { APIDataFetchingConfigurationInterface, InputAPIDataId, MongoDbPipeLineConfigInterface } from "./APIDataFetchingConfigurationInterface.js";
+import { APIDataFetchingConfigurationInterface, InputAPIDataId, MongoDbPipeLineConfigInterface, PayloadTemplate, PayloadTemplateValue, RequestBodyMode } from "./APIDataFetchingConfigurationInterface.js";
 import { AutocapitalizeOptions, AutocompleteOptions, ElementTypes, IBasicFormInput, IFormElementTemplate, InputDataTypes, InputPipeTypes, InputTypes, OptionSelectTypes } from "./BasicFormInputInterface.js";
 import { IDateRangePickerInput } from "./DateRangePickerInput.js";
 import { AllDocumentFileExtensions, AllImageFileExtensions, FileUploadInputValueInterface, IFileUploadInput, InputFileType, UploadTypes } from "./FileUploadInputInterface.js";
@@ -19,10 +19,10 @@ import { TableColumnConfigInterface, TableConfigurationsInterface } from "./Tabl
 import { ITextareaProperties } from "./TextAreaInput.js";
 import { IToggleInput } from "./ToggleInputInterface.js";
 import { AdjResponseReviewColumnMapping, AdjudicationSteps, IWorkflowAdjudicationInput, WorkflowAdjudicationMicroFlowReviewValue, WorkflowAdjudicationResponseElectedSupplierSelectionValue, WorkflowAdjudicationScoreSheetValue } from "./WorkflowAdjudication.js";
-import { IWorkflowDocumentPicker, IWorkflowDocumentPickerConfig, workflowStepStatus } from "./WorkflowDocumentPicker.js";
+import { DOCUMENT_PICKER_FILTER_OPERATORS, DOCUMENT_PICKER_FILTER_VALUE_SOURCES, DOCUMENT_PICKER_FILTER_VALUE_TYPES, DocumentPickerFilterOperator, DocumentPickerFilterValueSource, DocumentPickerFilterValueType, IDocumentPage, IDocumentPickerFilter, IDocumentQueryRequest, IDocumentReference, IWorkflowDocumentPicker, IWorkflowDocumentPickerConfig, IWorkflowDocumentStepFilter, workflowStepStatus } from "./WorkflowDocumentPicker.js";
 import { CalculatedFieldRules } from "./calculatedFieldRules.js";
 import { CalculationFunctions, calculationVariableInterface } from "./calculationVariableInterface.js";
 import { IRichTextEditor, RichTextEditorType } from "./RichTextEditorInput.js";
 import { ValidationError, ValidationOptions } from "./schema.js";
 import { IUserSignature } from "./userSignature.js";
-export { ElementTypes, InputTypes, InputPipeTypes, AutocapitalizeOptions, AutocompleteOptions, InputDataTypes, MinInputTypes, IFormElementTemplate, IBasicFormInput, IFileUploadInput, IDateRangePickerInput, ITextareaProperties, IToggleInput, IMatrixInput, IMultiple, IMultipleInputCal, IScoaInput, TableConfigurationsInterface, TableColumnConfigInterface, FormControlCustomValidatorsInterface, InputObservedForChange, DraftFormControlCustomValidator, IFormValidationOverride, MinimumInputRequiredInterface, MinInputMapInput, CalculatedFieldRules, calculationVariableInterface, APIDataFetchingConfigurationInterface, IGetTreeResponse, CalculationFunctions, TreeNode, IPostmanCollection, IFolderItem, FileUploadInputValueInterface, AllDocumentFileExtensions, AllImageFileExtensions, UploadTypes, InputFileType, IScoaAccount, IScoaInputConfig, ITableScoaSelectionRow, ScoaSegmentValue, ScoaSegmentValueBag, IIncludedSegmentConfig, AccountingBasis, ScoaAccountTree, IUserSignature, ValidationOptions, ValidationError, MatDataOptionsInterface, MongoDbPipeLineConfigInterface, InputAPIDataId, FormInputBasicOptionInterface, ScoaInterface, ScoaInnerInput, IAccountSegmentTreeKeys, IWorkflowDocumentPicker, IWorkflowDocumentPickerConfig, workflowStepStatus, IWorkflowDocListCols, JsDataTypes, AdjudicationSteps, IWorkflowAdjudicationInput, WorkflowAdjudicationScoreSheetValue, WorkflowAdjudicationMicroFlowReviewValue, WorkflowAdjudicationResponseElectedSupplierSelectionValue, ScoreSheetItem, AdjResponseReviewColumnMapping, OptionSelectTypes, ISelectInputInterface, MultipleInputAvailableOperations, RichTextEditorType, IRichTextEditor, };
+export { ElementTypes, InputTypes, InputPipeTypes, AutocapitalizeOptions, AutocompleteOptions, InputDataTypes, MinInputTypes, IFormElementTemplate, IBasicFormInput, IFileUploadInput, IDateRangePickerInput, ITextareaProperties, IToggleInput, IMatrixInput, IMultiple, IMultipleInputCal, IScoaInput, TableConfigurationsInterface, TableColumnConfigInterface, FormControlCustomValidatorsInterface, InputObservedForChange, DraftFormControlCustomValidator, IFormValidationOverride, MinimumInputRequiredInterface, MinInputMapInput, CalculatedFieldRules, calculationVariableInterface, APIDataFetchingConfigurationInterface, PayloadTemplate, PayloadTemplateValue, RequestBodyMode, IGetTreeResponse, CalculationFunctions, TreeNode, IPostmanCollection, IFolderItem, FileUploadInputValueInterface, AllDocumentFileExtensions, AllImageFileExtensions, UploadTypes, InputFileType, IScoaAccount, IScoaInputConfig, ITableScoaSelectionRow, ScoaSegmentValue, ScoaSegmentValueBag, IIncludedSegmentConfig, AccountingBasis, ScoaAccountTree, IUserSignature, ValidationOptions, ValidationError, MatDataOptionsInterface, MongoDbPipeLineConfigInterface, InputAPIDataId, FormInputBasicOptionInterface, ScoaInterface, ScoaInnerInput, IAccountSegmentTreeKeys, IWorkflowDocumentPicker, IWorkflowDocumentPickerConfig, IWorkflowDocumentStepFilter, IDocumentPickerFilter, IDocumentPage, IDocumentQueryRequest, IDocumentReference, DocumentPickerFilterOperator, DocumentPickerFilterValueSource, DocumentPickerFilterValueType, DOCUMENT_PICKER_FILTER_OPERATORS, DOCUMENT_PICKER_FILTER_VALUE_SOURCES, DOCUMENT_PICKER_FILTER_VALUE_TYPES, workflowStepStatus, IWorkflowDocListCols, IWorkflowStepOption, JsDataTypes, AdjudicationSteps, IWorkflowAdjudicationInput, WorkflowAdjudicationScoreSheetValue, WorkflowAdjudicationMicroFlowReviewValue, WorkflowAdjudicationResponseElectedSupplierSelectionValue, ScoreSheetItem, AdjResponseReviewColumnMapping, OptionSelectTypes, ISelectInputInterface, MultipleInputAvailableOperations, RichTextEditorType, IRichTextEditor, };

package/dist/interfaces/formInput/index.js

@@ -4,7 +4,7 @@ import { AccountingBasis } from "./IMscoaAccount.js";
 import { JsDataTypes, MinInputTypes } from "./MinimumInputRequiredInterface.js";
 import { MultipleInputAvailableOperations } from "./MultipleInterface.js";
 import { AdjudicationSteps } from "./WorkflowAdjudication.js";
-import { workflowStepStatus } from "./WorkflowDocumentPicker.js";
+import { DOCUMENT_PICKER_FILTER_OPERATORS, DOCUMENT_PICKER_FILTER_VALUE_SOURCES, DOCUMENT_PICKER_FILTER_VALUE_TYPES, workflowStepStatus, } from "./WorkflowDocumentPicker.js";
 import { CalculationFunctions } from "./calculationVariableInterface.js";
 import { RichTextEditorType } from "./RichTextEditorInput.js";
 // H-018b (Worker T-C): `OLD_FormInterface` and `FormInterfaceMigration` are
@@ -14,4 +14,4 @@ import { RichTextEditorType } from "./RichTextEditorInput.js";
 // would otherwise trigger TS2300 "Duplicate identifier".
 export { 
 ///ENUMS
-ElementTypes, InputTypes, InputPipeTypes, AutocapitalizeOptions, AutocompleteOptions, InputDataTypes, MinInputTypes, CalculationFunctions, AllDocumentFileExtensions, AllImageFileExtensions, UploadTypes, InputFileType, AccountingBasis, workflowStepStatus, JsDataTypes, AdjudicationSteps, OptionSelectTypes, MultipleInputAvailableOperations, RichTextEditorType, };
+ElementTypes, InputTypes, InputPipeTypes, AutocapitalizeOptions, AutocompleteOptions, InputDataTypes, MinInputTypes, CalculationFunctions, AllDocumentFileExtensions, AllImageFileExtensions, UploadTypes, InputFileType, AccountingBasis, DOCUMENT_PICKER_FILTER_OPERATORS, DOCUMENT_PICKER_FILTER_VALUE_SOURCES, DOCUMENT_PICKER_FILTER_VALUE_TYPES, workflowStepStatus, JsDataTypes, AdjudicationSteps, OptionSelectTypes, MultipleInputAvailableOperations, RichTextEditorType, };

package/dist/schemas/DocmentPickerInputSchema.d.ts

@@ -1,3 +1,5 @@
 import Joi from 'joi';
+declare const documentPickerFilterSchema: Joi.ObjectSchema<any>;
+declare const workflowDocumentStepFilterSchema: Joi.ObjectSchema<any>;
 declare const workflowDocumentPickerConfigSchema: Joi.ObjectSchema<any>;
-export { workflowDocumentPickerConfigSchema };
+export { workflowDocumentPickerConfigSchema, documentPickerFilterSchema, workflowDocumentStepFilterSchema };

package/dist/schemas/DocmentPickerInputSchema.js

@@ -1,12 +1,40 @@
 import Joi from 'joi';
-import { APIDataFetchingConfigurationSchema, MongoDbPipeLineConfigSchema } from './MatOptionsSchema.js';
-import { DataSources } from '../interfaces/FormBuilder/index.js';
+import { DOCUMENT_PICKER_FILTER_OPERATORS, DOCUMENT_PICKER_FILTER_VALUE_SOURCES, DOCUMENT_PICKER_FILTER_VALUE_TYPES, } from '../interfaces/formInput/WorkflowDocumentPicker.js';
+// Schema for IDocumentPickerFilter
+const documentPickerFilterSchema = Joi.object({
+    // The record-list editor stamps an id on every filter it saves and tracks the row
+    // by it, so a persisted filter always carries one. Rejecting it made every saved
+    // preset filter fail validation on the next open.
+    id: Joi.string().optional(),
+    path: Joi.string().required(),
+    op: Joi.string().valid(...DOCUMENT_PICKER_FILTER_OPERATORS).optional(),
+    // Optional: absent means "infer from what is set", so filters saved before
+    // `valueSource` existed still validate.
+    valueSource: Joi.string().valid(...DOCUMENT_PICKER_FILTER_VALUE_SOURCES).optional(),
+    value: Joi.any().optional(),
+    valueType: Joi.string().valid(...DOCUMENT_PICKER_FILTER_VALUE_TYPES).optional(),
+    fromInputId: Joi.string().allow('').optional(),
+    omitWhenEmpty: Joi.boolean().optional(),
+});
+// Schema for IWorkflowDocumentStepFilter
+const workflowDocumentStepFilterSchema = Joi.object({
+    // Optional, because the step restriction itself is. The builder writes a stepFilter
+    // record as soon as the administrator opens that control, so requiring stepIds made
+    // "I looked at the step chooser and picked nothing" a validation failure. An empty
+    // or absent list means every step is eligible — what the runtime already assumes
+    // via `stepFilter?.stepIds ?? []`.
+    stepIds: Joi.array().items(Joi.string()).optional(),
+});
 // Schema for IWorkflowDocumentPickerConfig
 const workflowDocumentPickerConfigSchema = Joi.object({
     workflowId: Joi.string().required(),
     primaryIdentifierKey: Joi.array().items(Joi.object()).optional(),
     sampleDocument: Joi.object().optional(), // Optional field for sample document structure
-    documentSourceType: Joi.string().valid(...Object.values(DataSources), 'default').required(),
-    documentsSource: Joi.alternatives().try(APIDataFetchingConfigurationSchema, MongoDbPipeLineConfigSchema, Joi.object()).optional(),
+    stepFilter: workflowDocumentStepFilterSchema.optional(),
+    presetFilters: Joi.array().items(documentPickerFilterSchema).optional(),
+    availableSteps: Joi.array().items(Joi.object({
+        label: Joi.string().optional(),
+        value: Joi.string().required(),
+    })).optional(),
 });
-export { workflowDocumentPickerConfigSchema };
+export { workflowDocumentPickerConfigSchema, documentPickerFilterSchema, workflowDocumentStepFilterSchema };

package/dist/schemas/MatOptionsSchema.js

@@ -43,7 +43,16 @@ const APIDataFetchingConfigurationSchema = Joi.object({
         transferCache: Joi.alternatives().try(Joi.object({ includeHeaders: Joi.array().items(Joi.string()).optional() }), Joi.boolean()).optional()
     }).optional(),
     backEndConfig: Joi.object({
-        minimumInputRequired: Joi.array().items(minimumInputRequiredSchema).required()
+        // Optional: a 'template'-mode fetch shapes its body from payloadTemplate and
+        // carries no mapping; GET fetches never had one. Readers default it to [].
+        minimumInputRequired: Joi.array().items(minimumInputRequiredSchema).optional(),
+        // Which body mechanism is active; unset ⇒ 'mappedInputs' (backward compatible).
+        requestBodyMode: Joi.string().valid('mappedInputs', 'template').optional(),
+        // Free-form JSON body template ({{inputId}} tokens + typed default literals).
+        // Supersedes minimumInputRequired when set and mode is not 'mappedInputs'.
+        payloadTemplate: Joi.alternatives().try(Joi.object(), Joi.array()).optional(),
+        // Raw request body captured from the endpoint, used to seed the template editor.
+        requestBody: Joi.alternatives().try(Joi.object(), Joi.array()).optional()
     }).optional(),
     valueAccessRules: Joi.alternatives().try(FormInputBasicOptionSchema, Joi.array().items(Joi.object())).optional(),
     source: Joi.string().valid('local', 'api', 'mongoPipeline', 'customOptions').required(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngx-t-forms-types",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "description": "Typings and interfaces for the ngx-t-forms library for dynamic forms.",
   "keywords": [
     "typings",