@edgerules/portable 0.0.0-alpha.202607042221 → 0.0.0-alpha.202607061032

package/dist/portable.d.ts

@@ -88,7 +88,7 @@ export interface PortableTypedValue extends PortableObject {
  * The value of any field inside a context node. Reserved `@`-prefixed keys carry
  * string|number metadata (see the index signature below); all other keys hold a PortableNode.
  */
-export type PortableNode = PortableValue | PortableContext | PortableContext[] | PortableExpression | PortableTypedValue | PortableFunctionDefinition | PortableTypeDefinition | PortableInvocationDefinition;
+export type PortableNode = PortableValue | PortableContext | PortableContext[] | PortableExpression | PortableTypedValue | PortableFunctionDefinition | PortableRulesetDefinition | PortableTypeDefinition | PortableInvocationDefinition;
 /**
  * A context node — the model's record/object construct. In EdgeRules a record literal *is* a
  * context, so data records and model contexts are one and the same node.
@@ -171,10 +171,14 @@ export interface PortableFunctionSchema extends PortableObject {
     '@return': PortableTypeReference | PortableTypedValue;
 }
 /**
- * Used for setting or getting function invocation definitions.
- * - `@method` holds the function name, can also hold decision table hit-policy keywords (`firstMatch`, `uniqueMatch`, ...).
- * - `@arguments` holds the argument values; if the call takes no arguments, an empty array must be set.
- * `@arguments` can also hold a decision table definition (a `PortableContext` with `inputs`, `rules`, and optional `default`).
+ * Used for setting or getting function invocation definitions. A call to a `ruleset` is an
+ * ordinary invocation too — a ruleset is a callable just like a function, so there is no
+ * decision-table special case here.
+ * - `@method` holds the callee name (a function or a ruleset).
+ * - `@arguments` holds the argument values, either positional (an array, in call order; if the call takes no arguments,
+ *   an empty array must be set) or named (a `Record<string, PortableValue>` keyed by parameter name) — never both in
+ *   the same invocation. Named arguments are valid only for calls to user-defined functions/rulesets; built-in
+ *   functions always use the array form and reject the named form at link time.
  *
  * `@type` is available only in return object, it is linked type information for the invocation result, inferred by the engine and provided
  * for the host's convenience.
@@ -183,7 +187,54 @@ export interface PortableInvocationDefinition extends PortableObject {
     '@kind': 'invocation';
     '@type'?: PortableTypeReference;
     '@method': string;
-    '@arguments': PortableValue[];
+    '@arguments': PortableValue[] | Record<string, PortableValue>;
+}
+/**
+ * Used for setting or getting ruleset definitions. Mirrors `PortableFunctionDefinition`: the
+ * `@parameters` field holds the signature, `@hitPolicy` selects how matches resolve, `@rules`
+ * holds the ordered rule matrix, and `@default` is the optional fallback result.
+ *
+ * - `@default` is rejected when `@hitPolicy` is `"collect-matches"`.
+ * - Every rule's `then` (and `@default`, when present) must share one structural record shape.
+ *
+ * To get a ruleset definition, use:
+ *  - `service.get("risk.*")` -> returns the full `risk` ruleset definition
+ *  - `service.get("risk")` -> returns `risk`'s `ruleset-schema` (compact signature)
+ */
+export interface PortableRulesetDefinition extends PortableObject {
+    '@kind': 'ruleset';
+    '@parameters': Record<string, PortableTypeReference | PortableTypedValue | null>;
+    '@hitPolicy': 'first-match' | 'unique-match' | 'collect-matches' | 'best-match';
+    '@rules': PortableRule[];
+    '@default'?: PortableContext;
+}
+/**
+ * One rule row of a `PortableRulesetDefinition`. `when` maps a declared parameter name to a
+ * unary-test expression string (e.g. `"18..25"`, `"> 30000"`, `"any"`); an omitted column means
+ * "any" for that parameter. `then` is the rule's result record. `priority` is required when the
+ * ruleset's `@hitPolicy` is `"best-match"` and rejected otherwise.
+ */
+export interface PortableRule extends PortableObject {
+    '@kind': 'rule';
+    name?: string;
+    when?: Record<string, PortableExpressionString>;
+    then: PortableContext;
+    priority?: number;
+}
+/**
+ * Use only for getting ruleset schemas, usage:
+ *  - `service.get("risk")` -> returns `risk`'s schema
+ *  - `service.get("*")` -> returns all ruleset (and function) schemas in the context, because
+ *    default filter is "FIELDS"
+ *
+ * `@return` is the engine-inferred result type (structural), not a declared one — get-only, like
+ * `PortableFunctionSchema['@return']`.
+ */
+export interface PortableRulesetSchema extends PortableObject {
+    '@kind': 'ruleset-schema';
+    '@parameters': Record<string, PortableTypeReference | PortableTypedValue | null>;
+    '@hitPolicy': 'first-match' | 'unique-match' | 'collect-matches' | 'best-match';
+    '@return': PortableTypeReference | PortableTypedValue;
 }
 /** Machine-readable discriminant of a `PortableError`. */
 export type PortableErrorType = 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edgerules/portable",
-  "version": "0.0.0-alpha.202607042221",
+  "version": "0.0.0-alpha.202607061032",
   "type": "module",
   "description": "Portable JSON type definitions for EdgeRules.",
   "exports": {