ngx-t-forms-types 0.0.26 → 0.0.28

package/dist/interfaces/FormBuilder/DefaultEelement.js

@@ -32,6 +32,7 @@ export const DefaultInputConfig = {
             AllFormInputPrimaryKeys.Validators,
             AllFormInputPrimaryKeys.HintLabel,
             AllFormInputPrimaryKeys.MatOptions,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.Input,
@@ -60,6 +61,7 @@ export const DefaultInputConfig = {
             AllFormInputPrimaryKeys.Appearance,
             AllFormInputPrimaryKeys.FormControlName,
             AllFormInputPrimaryKeys.Validators, // Assuming Validators is also needed here
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.Location,
@@ -94,6 +96,7 @@ export const DefaultInputConfig = {
             AllFormInputPrimaryKeys.Type,
             AllFormInputPrimaryKeys.Value,
             AllFormInputPrimaryKeys.MatOptions,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.AutoCompleteInput,
@@ -130,6 +133,7 @@ export const DefaultInputConfig = {
             AllFormInputPrimaryKeys.HintLabel,
             AllFormInputPrimaryKeys.TrueLabel,
             AllFormInputPrimaryKeys.FalseLabel,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.Toggle,
@@ -176,6 +180,7 @@ export const DefaultInputConfig = {
             SpecialElementKeys.MatOptionsApiCall,
             AllFormInputPrimaryKeys.OptionSelectType,
             AllFormInputPrimaryKeys.AllowMultipleSelection,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.Select,
@@ -219,7 +224,8 @@ export const DefaultInputConfig = {
             AllFormInputPrimaryKeys.DataType,
             SpecialElementKeys.MatOptionsApiCall,
             AllFormInputPrimaryKeys.AllowMultipleSelection,
-            AllFormInputPrimaryKeys.PaginationSelectionConfig
+            AllFormInputPrimaryKeys.PaginationSelectionConfig,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.PaginatedSelectionTable,
@@ -253,6 +259,7 @@ export const DefaultInputConfig = {
             AllFormInputPrimaryKeys.ColSize,
             AllFormInputPrimaryKeys.Value,
             AllFormInputPrimaryKeys.HintLabel,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.IconSelect,
@@ -296,6 +303,7 @@ export const DefaultInputConfig = {
             FormInputKeys.Autocomplete,
             FormInputKeys.Placeholder,
             AllFormInputPrimaryKeys.Wrap,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.Textarea,
@@ -341,6 +349,7 @@ export const DefaultInputConfig = {
             FormInputKeys.PrefixIcon,
             FormInputKeys.PrefixText,
             FormInputKeys.SuffixText,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.DatePicker,
@@ -384,6 +393,7 @@ export const DefaultInputConfig = {
             FormInputKeys.PrefixIcon,
             FormInputKeys.PrefixText,
             FormInputKeys.SuffixText,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.DateRangePicker,
@@ -425,6 +435,7 @@ export const DefaultInputConfig = {
             AllFormInputPrimaryKeys.Value,
             AllFormInputPrimaryKeys.FileType,
             FormInputKeys.Accept,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.FileUpload,
@@ -459,6 +470,7 @@ export const DefaultInputConfig = {
             AllFormInputPrimaryKeys.Validators,
             AllFormInputPrimaryKeys.Required,
             AllFormInputPrimaryKeys.Value,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.Signature,
@@ -548,6 +560,7 @@ export const DefaultInputConfig = {
             AllFormInputPrimaryKeys.Validators,
             AllFormInputPrimaryKeys.Required,
             AllFormInputPrimaryKeys.Value,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.ImageCapture,
@@ -629,6 +642,7 @@ export const DefaultInputConfig = {
             AllFormInputPrimaryKeys.HintLabel,
             AllFormInputPrimaryKeys.WorkflowPickerConfig,
             AllFormInputPrimaryKeys.AllowMultipleSelection,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.WorkflowDocumentPicker,
@@ -663,7 +677,8 @@ export const DefaultInputConfig = {
             AllFormInputPrimaryKeys.AdjudicationStep,
             AllFormInputPrimaryKeys.AdjudicationPointTypes,
             AllFormInputPrimaryKeys.MinLength,
-            AllFormInputPrimaryKeys.MaxLength
+            AllFormInputPrimaryKeys.MaxLength,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.WorkflowAdjudication,
@@ -734,7 +749,8 @@ export const DefaultInputConfig = {
             AllFormInputPrimaryKeys.MatOptions,
             AllFormInputPrimaryKeys.FormInputs,
             AllFormInputPrimaryKeys.HandleLabel,
-            SpecialElementKeys.MultipleInputAvailableOperations
+            SpecialElementKeys.MultipleInputAvailableOperations,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.MultipleInput,
@@ -769,7 +785,8 @@ export const DefaultInputConfig = {
             AllFormInputPrimaryKeys.Required,
             AllFormInputPrimaryKeys.Value,
             AllFormInputPrimaryKeys.HintLabel,
-            AllFormInputPrimaryKeys.RichTextEditorLibrary
+            AllFormInputPrimaryKeys.RichTextEditorLibrary,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.Editor,
@@ -802,7 +819,8 @@ export const DefaultInputConfig = {
             SpecialElementKeys.ShowAllMcoaSegments,
             AllFormInputPrimaryKeys.TourContent,
             AllFormInputPrimaryKeys.MatOptions,
-            AllFormInputPrimaryKeys.MscoaConfig
+            AllFormInputPrimaryKeys.MscoaConfig,
+            AllFormInputPrimaryKeys.ConditionalInputConfig,
         ],
         elementTemplate: {
             element: ElementTypes.MscoaSelection,

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

@@ -38,7 +38,19 @@ export declare enum ElementEditorTypes {
     MapMatOptionsKeys = "mapMatOptionsKeys",
     FormPayloadProjection = "formPayloadProjection",
     /** Opt-in JSON body template ({@link PayloadTemplate}) for a POST value/options fetch. */
-    PayloadTemplate = "payloadTemplate"
+    PayloadTemplate = "payloadTemplate",
+    /** JSON request-header template ({@link HeaderTemplate}) for a value/options fetch (GET and POST alike). */
+    HeaderTemplate = "headerTemplate",
+    /** JSON query-parameter template ({@link QueryTemplate}) for a value/options fetch (GET and POST alike). */
+    QueryTemplate = "queryTemplate",
+    /**
+     * Composite editor owning a whole `matOptions.fetch.<slot>` API config:
+     * endpoint selection, query parameters, headers, body mapping/template and
+     * response mapping in one place. Replaces the seven per-slice rows in the
+     * default config; the individual editTypes above remain renderable for
+     * host-supplied custom `editorSections`.
+     */
+    ApiEndpointConfig = "apiEndpointConfig"
 }
 export interface ElementEditorConfigInterface {
     editorSections: Array<ElementEditorConfigSectionInterface>;

package/dist/interfaces/FormBuilder/elementEditor.js

@@ -33,6 +33,18 @@ export var ElementEditorTypes;
     ElementEditorTypes["FormPayloadProjection"] = "formPayloadProjection";
     /** Opt-in JSON body template ({@link PayloadTemplate}) for a POST value/options fetch. */
     ElementEditorTypes["PayloadTemplate"] = "payloadTemplate";
+    /** JSON request-header template ({@link HeaderTemplate}) for a value/options fetch (GET and POST alike). */
+    ElementEditorTypes["HeaderTemplate"] = "headerTemplate";
+    /** JSON query-parameter template ({@link QueryTemplate}) for a value/options fetch (GET and POST alike). */
+    ElementEditorTypes["QueryTemplate"] = "queryTemplate";
+    /**
+     * Composite editor owning a whole `matOptions.fetch.<slot>` API config:
+     * endpoint selection, query parameters, headers, body mapping/template and
+     * response mapping in one place. Replaces the seven per-slice rows in the
+     * default config; the individual editTypes above remain renderable for
+     * host-supplied custom `editorSections`.
+     */
+    ElementEditorTypes["ApiEndpointConfig"] = "apiEndpointConfig";
 })(ElementEditorTypes || (ElementEditorTypes = {}));
 // interface TStringExpressionValidationTest{
 //   expression: string;

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

@@ -818,21 +818,26 @@ export var ElementConfig = {
                     id: "865658d5-6ba4-4402-952f-731cfaeefb76"
                 },
                 {
+                    // The composite endpoint editor owns the WHOLE fetch slot:
+                    // endpoint pick, query params, headers, body mapping/template
+                    // and response mapping in one card. It replaced the seven
+                    // per-slice rows (ApiCall, Header/Query templates, body-mode
+                    // chip, RequiredInputs, PayloadTemplate, ApiValueAccessRules);
+                    // those editTypes stay renderable for host-supplied custom
+                    // editorSections. NO clearOnChange — the composite emits
+                    // complete slot values and manages endpoint switching itself.
                     name: SpecialElementKeys.Default,
                     deepBind: ['matOptions', 'fetch', 'value'],
-                    editType: ElementEditorTypes.ApiCall,
+                    editType: ElementEditorTypes.ApiEndpointConfig,
                     additionalTest: [
                         {
                             expression: `source === ${DataSources.Api}`,
                             deepBind: ['matOptions', 'fetch', 'value', 'source'],
                         },
                     ],
-                    clearOnChange: [
-                        ['matOptions', 'fetch', 'value'],
-                    ],
-                    hint: `Select an API endpoint from your Postman collection to fetch values. Configure headers, payload format, and response mapping as needed.`,
-                    label: 'Select API endpoint',
-                    id: "95724e64-9d5b-4260-866c-4ada95670b46"
+                    hint: `Select the API endpoint and configure the whole request in one place: query parameters, headers, body and response mapping.`,
+                    label: 'API endpoint',
+                    id: "c9e2f7a4-1b58-4d03-9a6e-2f84c1b0d597"
                 },
                 {
                     name: SpecialElementKeys.Default,
@@ -848,102 +853,6 @@ 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: [
-                        'matOptions',
-                        'fetch',
-                        'value',
-                        'backEndConfig',
-                        'minimumInputRequired',
-                    ],
-                    additionalTest: [
-                        {
-                            testType: 'exists',
-                            deepBind: [
-                                'matOptions',
-                                'fetch',
-                                'value',
-                                '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'],
-                    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: ['matOptions', 'fetch', 'value', '_id'],
-                    additionalTest: [
-                        {
-                            testType: 'exists',
-                            // Because only Api calls have value access rules
-                            deepBind: ['matOptions', 'fetch', 'value'],
-                        },
-                    ],
-                    editType: ElementEditorTypes.ApiValueAccessRules,
-                    label: 'Map value to fetched data',
-                    id: "26939f46-e8ed-404c-886e-2838495d56e6"
-                },
             ]
         },
         {
@@ -1023,103 +932,20 @@ export var ElementConfig = {
                     id: "4e31a786-ec96-4b42-8156-31357958c032"
                 },
                 {
+                    // Composite endpoint editor — see the value-slot twin above.
                     name: SpecialElementKeys.Default,
                     deepBind: ['matOptions', 'fetch', 'options'],
+                    editType: ElementEditorTypes.ApiEndpointConfig,
                     additionalTest: [
                         {
                             expression: "source === api",
                             deepBind: ['matOptions', 'fetch', 'options', 'source'],
                         },
                     ],
-                    editType: ElementEditorTypes.ApiCall,
-                    label: 'Select API to fetch data from',
+                    hint: `Select the API endpoint and configure the whole request in one place: query parameters, headers, body and response mapping.`,
+                    label: 'API endpoint',
                     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: [
-                        'matOptions',
-                        'fetch',
-                        'options',
-                        'backEndConfig',
-                        'minimumInputRequired',
-                    ],
-                    additionalTest: [
-                        {
-                            testType: 'exists',
-                            deepBind: [
-                                'matOptions',
-                                'fetch',
-                                'options',
-                                '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'],
-                    fetchOptions: ['matOptions', 'fetch', 'options', '_id'],
-                    additionalTest: [
-                        {
-                            testType: 'exists',
-                            deepBind: ['matOptions', 'fetch', 'options'],
-                        },
-                    ],
-                    editType: ElementEditorTypes.ApiValueAccessRules,
-                    label: 'Map option value to fetched data',
-                    id: "e24ce283-4cea-497e-b692-feeb4f3afbed"
-                },
             ]
         },
         {
@@ -1233,6 +1059,13 @@ export var ElementConfig = {
                     deepBind: ['validators'],
                     id: "babd1b19-aa49-41b6-bd06-1c34ea2b9fe0"
                 },
+                {
+                    name: AllFormInputPrimaryKeys.ConditionalInputConfig,
+                    editType: ElementEditorTypes.ConditionalInputConfig,
+                    label: 'Conditional display',
+                    deepBind: ['conditionalInputConfig'],
+                    id: "3f2b1c74-9d6e-4a58-9b2f-27c5a1e4d803"
+                },
             ],
         },
     ],

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

@@ -26,10 +26,22 @@ export interface Body {
     raw: string;
     options: Option;
 }
+/**
+ * One query-string entry on a captured Postman request URL. Postman marks a
+ * param the author unticked with `disabled: true` — such entries are excluded
+ * when seeding a fetch config's `capturedQuery`.
+ */
+export interface IUrlQueryParam {
+    key: string;
+    value: string;
+    disabled?: boolean;
+}
 export interface Url {
     raw: string;
     host: string[];
     path: string[];
+    /** Structured query params of the captured URL (absent when the URL has none). */
+    query?: IUrlQueryParam[];
 }
 export interface Request {
     method: 'GET' | 'POST' | 'PUT' | 'DELETE';

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

@@ -97,6 +97,12 @@ export interface IStoreFunctions {
     saveUserSignature: (signature: PointGroup[]) => Observable<void>;
     httpPostDataFunction: (url: string, data: any, options?: any) => Observable<any>;
     httpGetDataFunction: (url: string, options?: any) => Observable<any>;
+    /**
+     * Transport for a per-input value/options fetch whose `httpMethod` is `'PUT'`.
+     * Optional: when the host does not provide it, the library falls back to its
+     * own `HttpClient.put(url, data, options)` with the options bag forwarded.
+     */
+    httpPutDataFunction?: (url: string, data: any, options?: any) => Observable<any>;
     getCurrentStepMicroflowSubmissions: () => Observable<{
         submissions: any[];
         columnMapping: AdjResponseReviewColumnMapping;

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

@@ -1,5 +1,6 @@
 import { IStoreFunctions } from "./IStoreFunctions.js";
 import { Moment } from 'moment';
+import type { FormSubmissionHandleInterface } from "../Form/formSubmissionHandleInterface.js";
 export interface IFinancialCycles {
     CURRENT_FINANCIAL_CYCLE: string;
     CURRENT_FINANCIAL_CYCLE_START_DATE: Moment;
@@ -16,5 +17,37 @@ export interface IFinancialCycles {
 export interface NgxTFormsConfig {
     base_url?: string;
     formBuilder: IStoreFunctions;
+    /**
+     * Submission configuration pre-inserted into every NEW form the builder creates.
+     *
+     * Applies ONLY at new-form creation. Forms loaded from storage keep whatever they
+     * already carry — including nothing — so an author can delete the pre-inserted
+     * endpoints and have that stick. Changing this value never rewrites existing forms.
+     *
+     * The value is deep-copied per form, so the builder editing one form's submission
+     * config can never mutate this object or leak into the next new form. API entry
+     * `_id`s are copied verbatim, so the same default yields the same ids across forms.
+     *
+     * Omit it and new forms start with `{ submissionAPI: [] }`, exactly as before.
+     *
+     * @example
+     *   provideNgxTForms({
+     *     formBuilder: myStoreFunctions,
+     *     defaultSubmissionHandle: {
+     *       innerComponentShowSubmitButton: false,
+     *       submissionAPI: [{
+     *         _id: '80eca6b1-923a-4c0e-a863-2f56a7e52a67',
+     *         name: 'Generate/Update WF Document',
+     *         httpEndPoint: '{{$iserve-back-end-url}}/api/form/generateWFFormValues',
+     *         httpMethod: 'POST',
+     *         postFormData: true,
+     *         backEndConfig: { minimumInputRequired: [] },
+     *         source: DataSources.Api,
+     *         projectFormData: 'data:{$formValue}',
+     *       }],
+     *     },
+     *   })
+     */
+    defaultSubmissionHandle?: FormSubmissionHandleInterface;
     [key: string]: string | Object | undefined;
 }

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

@@ -65,6 +65,83 @@ export type PayloadTemplate = {
  * configuration.
  */
 export type RequestBodyMode = 'mappedInputs' | 'template';
+/**
+ * A single header value in a {@link HeaderTemplate}.
+ *
+ * Scalars only — an HTTP header value is text on the wire, so a number/boolean
+ * literal is stringified at request time. Nesting is deliberately not expressible:
+ * a header has no structure to nest into.
+ */
+export type HeaderTemplateValue = string | number | boolean;
+/**
+ * Declarative request headers for a value/options fetch, authored in the same
+ * JSON editor as {@link PayloadTemplate} and resolved with the same
+ * `{{inputId}}` token syntax.
+ *
+ * A value that is EXACTLY `"{{inputId}}"` is replaced by that input's live value
+ * (stringified); a value that merely CONTAINS token(s) is interpolated
+ * (`"Bearer {{accessToken}}"`); every other literal is a fixed default. Header
+ * names are always literal.
+ *
+ * Applies to GET as well as POST — headers are a transport concern, not a body
+ * concern. The resolved map is merged into
+ * {@link APIDataFetchingConfigurationInterface.httpHeaderOptions}`.headers`
+ * (the template wins on a name collision) before the request is issued.
+ *
+ * Like a payload template, a token that resolves empty keeps the fetch **idle**:
+ * a request that would go out without its `Authorization`/tenant header is a
+ * request that fails, so the engine waits for the bound field instead of issuing
+ * a doomed call.
+ *
+ * @example
+ *   headerTemplate: {
+ *     Authorization: 'Bearer {{accessToken}}',
+ *     'x-tenant-id': '{{municipality}}',
+ *     'Content-Type': 'application/json',
+ *   }
+ */
+export type HeaderTemplate = {
+    [headerName: string]: HeaderTemplateValue;
+};
+/**
+ * A single query-parameter value in a {@link QueryTemplate}.
+ *
+ * Scalars only — a URL query parameter is text on the wire, so a number/boolean
+ * literal is stringified at request time. The exact structural twin of
+ * {@link HeaderTemplateValue}.
+ */
+export type QueryTemplateValue = string | number | boolean;
+/**
+ * Declarative URL query parameters for a value/options fetch — the exact
+ * structural twin of {@link HeaderTemplate}, resolved with the same
+ * `{{inputId}}` token syntax.
+ *
+ * A value that is EXACTLY `"{{inputId}}"` is replaced by that input's live value
+ * (stringified); a value that merely CONTAINS token(s) is interpolated
+ * (`"za-{{province}}"`); every other literal is a fixed default. Parameter
+ * names are always literal.
+ *
+ * Applies to GET as well as POST — query parameters are a transport concern.
+ * The resolved map is merged into
+ * {@link APIDataFetchingConfigurationInterface.httpHeaderOptions}`.params`
+ * (the template wins on a name collision) before the request is issued; any
+ * literal query text already inside `httpEndPoint` is left untouched and the
+ * HTTP layer appends the params after it.
+ *
+ * Like a header template, a token that resolves empty keeps the fetch **idle**:
+ * a request missing a bound parameter would return the wrong data, so the
+ * engine waits for the bound field instead.
+ *
+ * @example
+ *   queryTemplate: {
+ *     financialYear: '{{financialYear}}',
+ *     department: '{{departmentId}}',
+ *     pageSize: 50,
+ *   }
+ */
+export type QueryTemplate = {
+    [paramName: string]: QueryTemplateValue;
+};
 export interface APIDataFetchingConfigurationInterface extends DataFetchingBaseConfig {
     _id: string;
     name: string;
@@ -89,6 +166,39 @@ export interface APIDataFetchingConfigurationInterface extends DataFetchingBaseC
             includeHeaders?: string[];
         } | boolean;
     };
+    /**
+     * Author-configured request headers, optionally bound to live form values (see
+     * {@link HeaderTemplate}). Merged over {@link httpHeaderOptions}`.headers` at
+     * request time; absent means "send exactly what `httpHeaderOptions` says",
+     * which is the historical behaviour.
+     */
+    headerTemplate?: HeaderTemplate;
+    /**
+     * The headers captured from the selected endpoint (e.g. the Postman request's
+     * enabled headers). Persisted only to seed {@link headerTemplate}'s editor so
+     * it never opens blank; never sent on its own.
+     */
+    capturedHeaders?: HeaderTemplate;
+    /**
+     * Author-configured URL query parameters, optionally bound to live form values
+     * (see {@link QueryTemplate}). Merged over {@link httpHeaderOptions}`.params`
+     * at request time; absent means "send exactly what `httpHeaderOptions` says",
+     * which is the historical behaviour.
+     */
+    queryTemplate?: QueryTemplate;
+    /**
+     * The query parameters captured from the selected endpoint's URL (e.g. the
+     * Postman request's enabled `url.query` entries). Persisted only to seed
+     * {@link queryTemplate}'s editor so it never opens blank; never sent on its
+     * own — mirrors {@link capturedHeaders}.
+     */
+    capturedQuery?: QueryTemplate;
+    /**
+     * The endpoint's documentation captured verbatim from the Postman request's
+     * `description`. Display-only (the editor's Docs tab); never sent, never
+     * interpreted — mirrors the other `captured*` seeds.
+     */
+    capturedDocs?: string;
     backEndConfig: {
         /**
          * The default/mapTo mapping that shapes the POST body in `'mappedInputs'` mode.

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

@@ -1,7 +1,72 @@
+import { InputObservedForChange } from "./FormControlCustomValidatorsInterface.js";
+/**
+ * One conditional-display rule declared on a form input's
+ * `conditionalInputConfig`.
+ *
+ * ### Two shapes, one field
+ *
+ * The interface carries an **expression** half (read by the engine) and a
+ * legacy **descriptive** half (read by external consumers that render authoring
+ * guidance). This mirrors `ConfigurationValidTestInterface`, which solved the
+ * same migration by making the legacy fields optional and adding `expression`
+ * alongside them.
+ *
+ * - A rule with an `expression` participates in the runtime visibility gate.
+ * - A rule without one is inert to the engine — it is descriptive metadata only,
+ *   and the input stays visible as far as that rule is concerned.
+ *
+ * ### Combination
+ *
+ * Multiple rules combine with **AND**: the input is revealed only when every
+ * expression-bearing rule evaluates to `true`. This matches how every other
+ * show-gate in the form builder composes (`additionalTest` entries are all
+ * applied with `.every`). An absent or empty array means *always visible*.
+ *
+ * @example Reveal a phone-number field only when the contact method is 'phone'.
+ * ```ts
+ * conditionalInputConfig: [{
+ *   id: 'reveal-phone',
+ *   expression: 'contactMethod === "phone"',
+ *   inputsObservedForChanges: [{ inputId: 'a1b2', variable: 'contactMethod' }],
+ * }]
+ * ```
+ */
 export interface ConditionalInputRule {
-    formControlName: string;
-    label: string;
-    testType: string;
-    valueMatch: string;
+    /** Stable rule identifier. */
     id: string;
+    /**
+     * Predicate expression over the observed inputs' values. Evaluating to
+     * `true` means the input is **REVEALED**.
+     *
+     * Same DSL as a custom validator's `expression`, with the opposite polarity:
+     * a validator's `true` means *invalid*, a rule's `true` means *shown*.
+     */
+    expression?: string;
+    /**
+     * Dependency list auto-derived from {@link ConditionalInputRule.expression},
+     * exactly as custom validators derive theirs. Each entry binds a variable
+     * name used in the expression to the input whose value supplies it.
+     */
+    inputsObservedForChanges?: InputObservedForChange[];
+    /**
+     * @deprecated Legacy descriptive shape. Never read by the engine; retained
+     *   because external consumers render it as authoring guidance. Author new
+     *   rules with {@link ConditionalInputRule.expression}.
+     */
+    formControlName?: string;
+    /**
+     * @deprecated Legacy descriptive shape — see
+     *   {@link ConditionalInputRule.formControlName}.
+     */
+    label?: string;
+    /**
+     * @deprecated Legacy descriptive shape — see
+     *   {@link ConditionalInputRule.formControlName}.
+     */
+    testType?: string;
+    /**
+     * @deprecated Legacy descriptive shape — see
+     *   {@link ConditionalInputRule.formControlName}.
+     */
+    valueMatch?: string;
 }

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

@@ -3,6 +3,11 @@ export declare enum MinInputTypes {
     Default = "default",
     MapTo = "mapto",
     MapDocFilter = "mapDocFilter",
+    /**
+     * @deprecated Never implemented. No editor offers it, no runtime handles it —
+     * a `bind` entry leaves its fetch permanently idle. The runtime now surfaces a
+     * config error when it encounters one. Re-map the entry as {@link MapTo}.
+     */
     Bind = "bind"
 }
 export declare enum JsDataTypes {

package/dist/interfaces/formInput/MinimumInputRequiredInterface.js

@@ -3,6 +3,11 @@ export var MinInputTypes;
     MinInputTypes["Default"] = "default";
     MinInputTypes["MapTo"] = "mapto";
     MinInputTypes["MapDocFilter"] = "mapDocFilter";
+    /**
+     * @deprecated Never implemented. No editor offers it, no runtime handles it —
+     * a `bind` entry leaves its fetch permanently idle. The runtime now surfaces a
+     * config error when it encounters one. Re-map the entry as {@link MapTo}.
+     */
     MinInputTypes["Bind"] = "bind";
 })(MinInputTypes || (MinInputTypes = {}));
 export var JsDataTypes;

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

@@ -1,8 +1,9 @@
 import { IFolderItem, IPostmanCollection } from "../FormBuilder/postmanCollection.js";
 import { IWorkflowDocListCols, IWorkflowStepOption } from "../FormBuilder/workflowSelectionConfig.js";
 import { TreeNode } from "../FormSlide/accessTree.js";
-import { APIDataFetchingConfigurationInterface, InputAPIDataId, MongoDbPipeLineConfigInterface, PayloadTemplate, PayloadTemplateValue, RequestBodyMode } from "./APIDataFetchingConfigurationInterface.js";
+import { APIDataFetchingConfigurationInterface, HeaderTemplate, HeaderTemplateValue, InputAPIDataId, MongoDbPipeLineConfigInterface, PayloadTemplate, PayloadTemplateValue, QueryTemplate, QueryTemplateValue, RequestBodyMode } from "./APIDataFetchingConfigurationInterface.js";
 import { AutocapitalizeOptions, AutocompleteOptions, ElementTypes, IBasicFormInput, IFormElementTemplate, InputDataTypes, InputPipeTypes, InputTypes, OptionSelectTypes } from "./BasicFormInputInterface.js";
+import { ConditionalInputRule } from "./ConditionalInputRule.js";
 import { IDateRangePickerInput } from "./DateRangePickerInput.js";
 import { AllDocumentFileExtensions, AllImageFileExtensions, FileUploadInputValueInterface, IFileUploadInput, InputFileType, UploadTypes } from "./FileUploadInputInterface.js";
 import { DraftFormControlCustomValidator, FormControlCustomValidatorsInterface, InputObservedForChange } from "./FormControlCustomValidatorsInterface.js";
@@ -25,4 +26,4 @@ import { CalculationFunctions, calculationVariableInterface } from "./calculatio
 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, 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, };
+export { ElementTypes, InputTypes, InputPipeTypes, AutocapitalizeOptions, AutocompleteOptions, InputDataTypes, MinInputTypes, IFormElementTemplate, IBasicFormInput, IFileUploadInput, ConditionalInputRule, IDateRangePickerInput, ITextareaProperties, IToggleInput, IMatrixInput, IMultiple, IMultipleInputCal, IScoaInput, TableConfigurationsInterface, TableColumnConfigInterface, FormControlCustomValidatorsInterface, InputObservedForChange, DraftFormControlCustomValidator, IFormValidationOverride, MinimumInputRequiredInterface, MinInputMapInput, CalculatedFieldRules, calculationVariableInterface, APIDataFetchingConfigurationInterface, PayloadTemplate, PayloadTemplateValue, RequestBodyMode, HeaderTemplate, HeaderTemplateValue, QueryTemplate, QueryTemplateValue, 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/upgradeFunctions/interfaces/init-form.d.ts

@@ -1,6 +1,12 @@
 import { IIncludedSegmentConfig } from "../../formInput/index.js";
 /** Plain-union mirror of Angular Material's `MatFormFieldAppearance` (no `@angular/material` dependency). */
 type MatFormFieldAppearance = 'fill' | 'outline';
+/**
+ * FROZEN legacy snapshot of the pre-upgrade rule shape. Deliberately NOT kept in
+ * step with the canonical {@link ConditionalInputRule} — this module describes
+ * the *old* document a form is upgraded FROM, so widening it would misdescribe
+ * the input of the upgrade.
+ */
 interface conditionalInputRule {
     formControlName: string;
     label: string;

package/dist/schemas/MatOptionsSchema.js

@@ -22,6 +22,10 @@ const minimumInputRequiredSchema = Joi.object({
     activeChangeId: Joi.string().optional(),
     primaryKey: Joi.boolean().optional()
 });
+/** A flat `header name → scalar value` map (see `HeaderTemplate`). */
+const headerTemplateSchema = Joi.object().pattern(Joi.string(), Joi.alternatives().try(Joi.string().allow(''), Joi.number(), Joi.boolean()));
+/** A flat `param name → scalar value` map (see `QueryTemplate`) — twin of the header schema. */
+const queryTemplateSchema = Joi.object().pattern(Joi.string(), Joi.alternatives().try(Joi.string().allow(''), Joi.number(), Joi.boolean()));
 const APIDataFetchingConfigurationSchema = Joi.object({
     _id: Joi.string().required(),
     name: Joi.string().required(),
@@ -42,6 +46,19 @@ const APIDataFetchingConfigurationSchema = Joi.object({
         withCredentials: Joi.boolean().optional(),
         transferCache: Joi.alternatives().try(Joi.object({ includeHeaders: Joi.array().items(Joi.string()).optional() }), Joi.boolean()).optional()
     }).optional(),
+    // Author-configured headers, values optionally carrying {{inputId}} tokens bound to
+    // live form values. Flat by construction — a header value is text on the wire, so
+    // only scalars are accepted (numbers/booleans are stringified at request time).
+    headerTemplate: headerTemplateSchema.optional(),
+    // Headers captured from the selected endpoint; seeds the editor, never sent alone.
+    capturedHeaders: headerTemplateSchema.optional(),
+    // Author-configured URL query params, values optionally carrying {{inputId}} tokens.
+    // Flat scalars only — a query param is text on the wire.
+    queryTemplate: queryTemplateSchema.optional(),
+    // Query params captured from the endpoint's URL; seeds the editor, never sent alone.
+    capturedQuery: queryTemplateSchema.optional(),
+    // The endpoint's Postman description, verbatim; display-only (Docs tab).
+    capturedDocs: Joi.string().allow('').optional(),
     backEndConfig: Joi.object({
         // Optional: a 'template'-mode fetch shapes its body from payloadTemplate and
         // carries no mapping; GET fetches never had one. Readers default it to [].

package/package.json

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

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

@@ -1,31 +0,0 @@
-declare enum EditType {
-    Input = "input",
-    Toggle = "toggle",
-    ChipSelect = "chipSelect",
-    OptionSelect = "optionSelect",
-    Range = "range",
-    MinMaxValue = "minMaxValue",
-    DocumentPropertyPicker = "documentPropertyPicker",
-    ManualDocumentPropertyPicker = "manualDocumentPropertyPicker",
-    FormInputSelector = "formInputSelector",
-    SelectAForm = "selectAForm",
-    WorkflowPicker = "workflowPicker",
-    WorkflowStepPicker = "workflowStepPicker",
-    WorkflowDocumentListLabels = "workflowDocumentListLabels",
-    DecisionGateSettings = "decisionGateSettings",
-    EscalateTask = "escalateTask",
-    AddMembers = "addMembers",
-    MultipleInputConfigurations = "multipleInputConfigurations",
-    TableConfigSetup = "tableConfigSetup",
-    SelectionOptions = "selectionOptions",
-    ApiValueAccessRules = "apiValueAccessRules",
-    RequiredInputs = "requiredInputs",
-    ChartAxis = "chartAxis",
-    Series = "series",
-    MongoPipelineBuilder = "mongoPipelineBuilder",
-    ApiCall = "apiCall",
-    ConfigMscoaSegments = "configMscoaSegments",
-    ConfigMscoaAdditionalInputs = "configMscoaAdditionalInputs",
-    Validators = "validators",
-    CalculatedFieldRules = "calculatedFieldRules"
-}

package/dist/interfaces/FormBuilder/ElementEditorTypes.js

@@ -1,40 +0,0 @@
-"use strict";
-var EditType;
-(function (EditType) {
-    // Basic Input Types
-    EditType["Input"] = "input";
-    EditType["Toggle"] = "toggle";
-    EditType["ChipSelect"] = "chipSelect";
-    EditType["OptionSelect"] = "optionSelect";
-    EditType["Range"] = "range";
-    EditType["MinMaxValue"] = "minMaxValue";
-    // Document/Form Pickers
-    EditType["DocumentPropertyPicker"] = "documentPropertyPicker";
-    EditType["ManualDocumentPropertyPicker"] = "manualDocumentPropertyPicker";
-    EditType["FormInputSelector"] = "formInputSelector";
-    EditType["SelectAForm"] = "selectAForm";
-    // Workflow Related
-    EditType["WorkflowPicker"] = "workflowPicker";
-    EditType["WorkflowStepPicker"] = "workflowStepPicker";
-    EditType["WorkflowDocumentListLabels"] = "workflowDocumentListLabels";
-    EditType["DecisionGateSettings"] = "decisionGateSettings";
-    EditType["EscalateTask"] = "escalateTask";
-    EditType["AddMembers"] = "addMembers";
-    // Multiple Configurations
-    EditType["MultipleInputConfigurations"] = "multipleInputConfigurations";
-    EditType["TableConfigSetup"] = "tableConfigSetup";
-    EditType["SelectionOptions"] = "selectionOptions";
-    EditType["ApiValueAccessRules"] = "apiValueAccessRules";
-    EditType["RequiredInputs"] = "requiredInputs";
-    // Chart/Report Related  
-    EditType["ChartAxis"] = "chartAxis";
-    EditType["Series"] = "series";
-    EditType["MongoPipelineBuilder"] = "mongoPipelineBuilder";
-    EditType["ApiCall"] = "apiCall";
-    // MSCOA Related
-    EditType["ConfigMscoaSegments"] = "configMscoaSegments";
-    EditType["ConfigMscoaAdditionalInputs"] = "configMscoaAdditionalInputs";
-    // Validation/Rules
-    EditType["Validators"] = "validators";
-    EditType["CalculatedFieldRules"] = "calculatedFieldRules";
-})(EditType || (EditType = {}));