@epilot/sdk 2.20.76 → 2.20.78

package/dist/{validation-rules.d-C1OtLama.d.ts → validation-rules.d-Dw7Qn8_e.d.ts}

@@ -152,19 +152,24 @@ declare namespace Components {
          * are resolved only for authenticated consumers (epilot 360 users and portal end customers);
          * in public journeys the dependent conditions are skipped.
          *
+         * A hook may declare value inputs (`contexts` entries `{ "type": "value", "name", "value_type" }`)
+         * besides the entities it receives. `inputs` supplies them from rule parameters, which the
+         * consumer binds like any other parameter and sends to the hook as `Context.<name>`.
+         *
          */
         ExternalValue | /**
-         * A comparison value supplied by the surface that evaluates the rule, identified by a name
-         * the rule chooses (e.g. `start_date`). The rule stores the name only. The consuming surface
-         * binds the name to a source of its own - a journey binds it to the value of another block -
-         * and resolves it at evaluation time, so the rule never references the surface's objects
-         * and stays reusable across journeys and forms.
+         * A comparison value supplied by the consumer that evaluates the rule, identified by a name
+         * the rule chooses (e.g. `start_date`). The rule stores the name only. The consumer binds the
+         * name to a source of its own - a journey binds it to the value of another block - and
+         * resolves it at evaluation time, so the rule never references the consumer's objects and
+         * stays reusable across journeys and forms.
          *
-         * The kind a parameter is compared as follows from the field it sits in: `number`, `text`
-         * or `date` for comparison values, range bounds, adjustment amounts and relative date
-         * offsets, or a number, string or boolean as an `applies_when` value. One name is compared
-         * as one kind throughout a rule; a rule using a name as two kinds is rejected at write time.
-         * A parameter the surface leaves unbound or empty leaves the comparison unresolved.
+         * A parameter's kind is determined by the field it is used in: `number`, `text` or `date`
+         * for comparison values, range bounds, adjustment amounts and relative date offsets, or a
+         * number, string or boolean as an `applies_when` value, or the `value_type` of the External
+         * Values hook input it supplies (`ExternalValue.inputs`). One name is compared as one kind
+         * throughout a rule; a rule using a name as two kinds is rejected at write time. A parameter
+         * the consumer leaves unbound or empty leaves the comparison unresolved.
          *
          */
         ParameterValue | /* A lower and upper bound for range operators (between, dateBetween, lengthBetween). Bounds are inclusive. */ RangeValue | /* No comparison value - used by unary operators such as notInFuture / notInPast. */ NoValue;
@@ -401,6 +406,10 @@ declare namespace Components {
          * are resolved only for authenticated consumers (epilot 360 users and portal end customers);
          * in public journeys the dependent conditions are skipped.
          *
+         * A hook may declare value inputs (`contexts` entries `{ "type": "value", "name", "value_type" }`)
+         * besides the entities it receives. `inputs` supplies them from rule parameters, which the
+         * consumer binds like any other parameter and sends to the hook as `Context.<name>`.
+         *
          */
         export interface ExternalValue {
             source: "external";
@@ -416,6 +425,34 @@ declare namespace Components {
              * ID of the result entry within the hook whose value is compared.
              */
             result_id: string; // ^[a-zA-Z0-9_-]+$
+            /**
+             * Values for the hook's value inputs, keyed by the input name the hook declares
+             * (`contexts` entry of type `value`), e.g. `{ "reading_date": { "source": "parameter", "name": "reading_date" } }`.
+             * Only parameters are supported. Write-time validation checks that every key is a value input the
+             * hook declares and uses the input's `value_type` (`number`, `text`, `date` or `boolean`) as the
+             * parameter's kind, so the parameter must not be compared as another kind elsewhere in the rule.
+             * An input parameter must not carry an adjustment. Declared inputs without an entry are allowed;
+             * the consumer omits an input that has no value.
+             *
+             */
+            inputs?: {
+                [name: string]: /**
+                 * A comparison value supplied by the consumer that evaluates the rule, identified by a name
+                 * the rule chooses (e.g. `start_date`). The rule stores the name only. The consumer binds the
+                 * name to a source of its own - a journey binds it to the value of another block - and
+                 * resolves it at evaluation time, so the rule never references the consumer's objects and
+                 * stays reusable across journeys and forms.
+                 *
+                 * A parameter's kind is determined by the field it is used in: `number`, `text` or `date`
+                 * for comparison values, range bounds, adjustment amounts and relative date offsets, or a
+                 * number, string or boolean as an `applies_when` value, or the `value_type` of the External
+                 * Values hook input it supplies (`ExternalValue.inputs`). One name is compared as one kind
+                 * throughout a rule; a rule using a name as two kinds is rejected at write time. A parameter
+                 * the consumer leaves unbound or empty leaves the comparison unresolved.
+                 *
+                 */
+                ParameterValue;
+            };
             adjust?: /**
              * Adjusts a context-resolved numeric value before comparison, e.g. "context value plus 10 percent".
              * Used to express tolerance bands such as "at most 10% above the current instalment amount".
@@ -597,17 +634,18 @@ declare namespace Components {
          */
         export type Operator = "equal" | "notEqual" | "greaterThan" | "greaterThanInclusive" | "lessThan" | "lessThanInclusive" | "between" | "dateBefore" | "dateOnOrBefore" | "dateAfter" | "dateOnOrAfter" | "dateBetween" | "notInFuture" | "notInPast" | "contains" | "doesNotContain" | "startsWith" | "endsWith" | "regexMatch" | "lengthBetween" | "maxDigits" | "maxDecimals";
         /**
-         * A comparison value supplied by the surface that evaluates the rule, identified by a name
-         * the rule chooses (e.g. `start_date`). The rule stores the name only. The consuming surface
-         * binds the name to a source of its own - a journey binds it to the value of another block -
-         * and resolves it at evaluation time, so the rule never references the surface's objects
-         * and stays reusable across journeys and forms.
+         * A comparison value supplied by the consumer that evaluates the rule, identified by a name
+         * the rule chooses (e.g. `start_date`). The rule stores the name only. The consumer binds the
+         * name to a source of its own - a journey binds it to the value of another block - and
+         * resolves it at evaluation time, so the rule never references the consumer's objects and
+         * stays reusable across journeys and forms.
          *
-         * The kind a parameter is compared as follows from the field it sits in: `number`, `text`
-         * or `date` for comparison values, range bounds, adjustment amounts and relative date
-         * offsets, or a number, string or boolean as an `applies_when` value. One name is compared
-         * as one kind throughout a rule; a rule using a name as two kinds is rejected at write time.
-         * A parameter the surface leaves unbound or empty leaves the comparison unresolved.
+         * A parameter's kind is determined by the field it is used in: `number`, `text` or `date`
+         * for comparison values, range bounds, adjustment amounts and relative date offsets, or a
+         * number, string or boolean as an `applies_when` value, or the `value_type` of the External
+         * Values hook input it supplies (`ExternalValue.inputs`). One name is compared as one kind
+         * throughout a rule; a rule using a name as two kinds is rejected at write time. A parameter
+         * the consumer leaves unbound or empty leaves the comparison unresolved.
          *
          */
         export interface ParameterValue {
@@ -941,19 +979,24 @@ declare namespace Components {
          * are resolved only for authenticated consumers (epilot 360 users and portal end customers);
          * in public journeys the dependent conditions are skipped.
          *
+         * A hook may declare value inputs (`contexts` entries `{ "type": "value", "name", "value_type" }`)
+         * besides the entities it receives. `inputs` supplies them from rule parameters, which the
+         * consumer binds like any other parameter and sends to the hook as `Context.<name>`.
+         *
          */
         ExternalValue | /**
-         * A comparison value supplied by the surface that evaluates the rule, identified by a name
-         * the rule chooses (e.g. `start_date`). The rule stores the name only. The consuming surface
-         * binds the name to a source of its own - a journey binds it to the value of another block -
-         * and resolves it at evaluation time, so the rule never references the surface's objects
-         * and stays reusable across journeys and forms.
+         * A comparison value supplied by the consumer that evaluates the rule, identified by a name
+         * the rule chooses (e.g. `start_date`). The rule stores the name only. The consumer binds the
+         * name to a source of its own - a journey binds it to the value of another block - and
+         * resolves it at evaluation time, so the rule never references the consumer's objects and
+         * stays reusable across journeys and forms.
          *
-         * The kind a parameter is compared as follows from the field it sits in: `number`, `text`
-         * or `date` for comparison values, range bounds, adjustment amounts and relative date
-         * offsets, or a number, string or boolean as an `applies_when` value. One name is compared
-         * as one kind throughout a rule; a rule using a name as two kinds is rejected at write time.
-         * A parameter the surface leaves unbound or empty leaves the comparison unresolved.
+         * A parameter's kind is determined by the field it is used in: `number`, `text` or `date`
+         * for comparison values, range bounds, adjustment amounts and relative date offsets, or a
+         * number, string or boolean as an `applies_when` value, or the `value_type` of the External
+         * Values hook input it supplies (`ExternalValue.inputs`). One name is compared as one kind
+         * throughout a rule; a rule using a name as two kinds is rejected at write time. A parameter
+         * the consumer leaves unbound or empty leaves the comparison unresolved.
          *
          */
         ParameterValue;
@@ -1279,19 +1322,24 @@ declare namespace Components {
          * are resolved only for authenticated consumers (epilot 360 users and portal end customers);
          * in public journeys the dependent conditions are skipped.
          *
+         * A hook may declare value inputs (`contexts` entries `{ "type": "value", "name", "value_type" }`)
+         * besides the entities it receives. `inputs` supplies them from rule parameters, which the
+         * consumer binds like any other parameter and sends to the hook as `Context.<name>`.
+         *
          */
         ExternalValue | /**
-         * A comparison value supplied by the surface that evaluates the rule, identified by a name
-         * the rule chooses (e.g. `start_date`). The rule stores the name only. The consuming surface
-         * binds the name to a source of its own - a journey binds it to the value of another block -
-         * and resolves it at evaluation time, so the rule never references the surface's objects
-         * and stays reusable across journeys and forms.
+         * A comparison value supplied by the consumer that evaluates the rule, identified by a name
+         * the rule chooses (e.g. `start_date`). The rule stores the name only. The consumer binds the
+         * name to a source of its own - a journey binds it to the value of another block - and
+         * resolves it at evaluation time, so the rule never references the consumer's objects and
+         * stays reusable across journeys and forms.
          *
-         * The kind a parameter is compared as follows from the field it sits in: `number`, `text`
-         * or `date` for comparison values, range bounds, adjustment amounts and relative date
-         * offsets, or a number, string or boolean as an `applies_when` value. One name is compared
-         * as one kind throughout a rule; a rule using a name as two kinds is rejected at write time.
-         * A parameter the surface leaves unbound or empty leaves the comparison unresolved.
+         * A parameter's kind is determined by the field it is used in: `number`, `text` or `date`
+         * for comparison values, range bounds, adjustment amounts and relative date offsets, or a
+         * number, string or boolean as an `applies_when` value, or the `value_type` of the External
+         * Values hook input it supplies (`ExternalValue.inputs`). One name is compared as one kind
+         * throughout a rule; a rule using a name as two kinds is rejected at write time. A parameter
+         * the consumer leaves unbound or empty leaves the comparison unresolved.
          *
          */
         ParameterValue;

package/docs/app.md

@@ -136,6 +136,9 @@ const { data } = await appClient.getPublicFacingComponent(...)
 - [`ApiProxyConfig`](#apiproxyconfig)
 - [`ExternalValuesConfig`](#externalvaluesconfig)
 - [`ExternalValuesHook`](#externalvalueshook)
+- [`ContextRequirement`](#contextrequirement)
+- [`EntityContextRequirement`](#entitycontextrequirement)
+- [`ValueContextRequirement`](#valuecontextrequirement)
 - [`ExternalValuesResult`](#externalvaluesresult)
 - [`Grants`](#grants)
 - [`BlueprintRef`](#blueprintref)
@@ -2268,6 +2271,7 @@ type ExternalValuesComponent = {
       result: { ... }
       timeout_ms?: { ... }
       on_unavailable?: { ... }
+      contexts?: { ... }
       cache?: { ... }
       secure_proxy?: { ... }
     }>
@@ -3797,6 +3801,14 @@ type ExternalValuesConfig = {
     }>
     timeout_ms?: number
     on_unavailable?: "skip" | "block"
+    contexts?: Array<{
+      type: { ... }
+      schema: { ... }
+    } | {
+      type: { ... }
+      name: { ... }
+      value_type: { ... }
+    }>
     cache?: {
       ttl_seconds: { ... }
       key?: { ... }
@@ -3811,9 +3823,9 @@ type ExternalValuesConfig = {
 
 ### `ExternalValuesHook`
 
-One external call that returns one or more typed results. Interpolated templates (Liquid) have access to `Context`, `Consumer`, `Options`, `Env` and — for `result` templates — `Response` and `AuthResponse` (each is also available snake_case, e.g. `{{ context.input }}`).
+One external call that returns one or more typed results. Interpolated templates (Liquid) have access to `Context`, `Consumer`, `Options`, `Env` and — for `result` templates — `Response` and `AuthResponse` (each is also available snake_case, e.g. `{{ context.contract }}`).
 
-`Context` is the single name
+`Context` is the name → v
 
 ```ts
 type ExternalValuesHook = {
@@ -3860,6 +3872,14 @@ type ExternalValuesHook = {
   }>
   timeout_ms?: number
   on_unavailable?: "skip" | "block"
+  contexts?: Array<{
+    type: "entity"
+    schema: string
+  } | {
+    type: "value"
+    name: string
+    value_type: "number" | "text" | "date" | "boolean"
+  }>
   cache?: {
     ttl_seconds: number
     key?: string
@@ -3871,6 +3891,44 @@ type ExternalValuesHook = {
 }
 ```
 
+### `ContextRequirement`
+
+A requirement a hook reads from `Context`, discriminated by `type`. More types will be added later; consumers must ignore types they do not know.
+
+```ts
+type ContextRequirement = {
+  type: "entity"
+  schema: string
+} | {
+  type: "value"
+  name: string
+  value_type: "number" | "text" | "date" | "boolean"
+}
+```
+
+### `EntityContextRequirement`
+
+The consumer supplies the bound entities of `schema` under `Context.`<schema>``.
+
+```ts
+type EntityContextRequirement = {
+  type: "entity"
+  schema: string
+}
+```
+
+### `ValueContextRequirement`
+
+The consumer supplies one scalar value under `Context.`<name>``, e.g. a date the customer entered in a journey block. A value input is optional: the consumer sends it when it has a value and omits it otherwise, so the hook's templates must cope with its absence, e.g. `{{ Context.reading_date | default
+
+```ts
+type ValueContextRequirement = {
+  type: "value"
+  name: string
+  value_type: "number" | "text" | "date" | "boolean"
+}
+```
+
 ### `ExternalValuesResult`
 
 A single typed value extracted from the hook response. Exactly one of `template`, `path` or `jsonata` must be set.

package/docs/external-values.md

@@ -40,6 +40,7 @@ const { data } = await externalValuesClient.listExternalValues(...)
 - [`ExternalValueHookSummary`](#externalvaluehooksummary)
 - [`ContextRequirement`](#contextrequirement)
 - [`EntityContextRequirement`](#entitycontextrequirement)
+- [`ValueContextRequirement`](#valuecontextrequirement)
 - [`ExternalValueHookList`](#externalvaluehooklist)
 
 ### `listExternalValues`
@@ -316,20 +317,29 @@ type ExternalValueHookSummary = {
   contexts?: Array<{
     type: "entity"
     schema: string
+  } | {
+    type: "value"
+    name: string
+    value_type: "number" | "text" | "date" | "boolean"
   }>
 }
 ```
 
 ### `ContextRequirement`
 
-Something a hook needs the consumer to supply in `context`, discriminated by `type`.
-Today only `entity`; more types will follow. Consumers ignore types they do not know.
+Something a hook needs the consumer to supply in `context`, discriminated by `type`:
+bound entities (`entity`) or an optional scalar input (`value`). More types may follow;
+consumers ignore types they do not know.
 
 
 ```ts
 type ContextRequirement = {
   type: "entity"
   schema: string
+} | {
+  type: "value"
+  name: string
+  value_type: "number" | "text" | "date" | "boolean"
 }
 ```
 
@@ -347,6 +357,21 @@ type EntityContextRequirement = {
 }
 ```
 
+### `ValueContextRequirement`
+
+An optional scalar input. When the consumer has a value it supplies it under
+`Context.`<name>`` (dates as ISO 8601 strings, `YYYY-MM-DD` or a date-time); otherwise the
+key is absent, so the hook template must provide a fallback, e.g.
+`{{ Context.reading_date | default: "now" | date: "%Y-%m-%d" }}` dec
+
+```ts
+type ValueContextRequirement = {
+  type: "value"
+  name: string
+  value_type: "number" | "text" | "date" | "boolean"
+}
+```
+
 ### `ExternalValueHookList`
 
 ```ts
@@ -371,6 +396,10 @@ type ExternalValueHookList = {
     contexts?: Array<{
       type: { ... }
       schema: { ... }
+    } | {
+      type: { ... }
+      name: { ... }
+      value_type: { ... }
     }>
   }>
 }