@cullet/erp-core 1.2.0 → 1.3.0

package/dist/plugins/index.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_plugin = require("../plugin.cjs");
+exports.PluginManager = require_plugin.PluginManager;

package/dist/plugins/index.d.cts

@@ -0,0 +1,2 @@
+import { a as PluginContract, i as PipelineReducer, n as BasePlugin, r as InvokeOptions, t as PluginManager } from "../plugin.cjs";
+export { BasePlugin, InvokeOptions, PipelineReducer, PluginContract, PluginManager };

package/dist/policies/engines/index.cjs

@@ -0,0 +1,10 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_gate_engine_registry = require("../../gate-engine-registry.cjs");
+exports.ComputeEngineRegistry = require_gate_engine_registry.ComputeEngineRegistry;
+exports.ComputeEvaluatorRegistry = require_gate_engine_registry.ComputeEvaluatorRegistry;
+exports.ComputePayloadParserRegistry = require_gate_engine_registry.ComputePayloadParserRegistry;
+exports.ComputePayloadParsers = require_gate_engine_registry.ComputePayloadParsers;
+exports.ComputeRegistry = require_gate_engine_registry.ComputeRegistry;
+exports.GateEngineRegistry = require_gate_engine_registry.GateEngineRegistry;
+exports.GatePayloadParserRegistry = require_gate_engine_registry.GatePayloadParserRegistry;
+exports.GatePayloadParsers = require_gate_engine_registry.GatePayloadParsers;

package/dist/policies/engines/index.d.cts

@@ -0,0 +1,4 @@
+import { A as ConditionEvaluationReportTag, D as ConditionEvaluationOptions, E as ConditionEvaluationCause, O as ConditionEvaluationReport, a as GateTraceNodeSnapshot, c as PolicyViolation, d as GatePayloadV1, i as GateTraceLeafSnapshot, j as ConditionEvaluatorReporter, k as ConditionEvaluationReportLevel, l as VersionedGateEngine, n as GateOutcomeData, o as GateViolationTrace, r as GateStatus, s as PolicyContext, t as GateOutcome, u as GatePayload } from "../../gate-types.cjs";
+import { a as ComputeOutcome, c as VersionedComputeEngine, d as ComputeDecisionTableRule, f as ComputeParamsPayload, i as ComputeEvaluatorRegistration, l as ComputePayload, n as ComputeRegistry, o as ComputeOutcomeData, p as ComputePayloadV1, r as ComputeEvaluator, s as ComputeStatus, t as GateEngineRegistry, u as ComputeDecisionTablePayload } from "../../gate-engine-registry.cjs";
+import { a as ComputePayloadParserRegistry, c as ComputeEvaluatorRegistry, i as ComputePayloadParser, n as GatePayloadParserRegistry, o as ComputePayloadParsers, r as GatePayloadParsers, s as ComputeEngineRegistry, t as GatePayloadParser } from "../../parse-gate-payload.cjs";
+export { ComputeDecisionTablePayload, ComputeDecisionTableRule, ComputeEngineRegistry, ComputeEvaluator, ComputeEvaluatorRegistration, ComputeEvaluatorRegistry, ComputeOutcome, ComputeOutcomeData, ComputeParamsPayload, ComputePayload, ComputePayloadParser, ComputePayloadParserRegistry, ComputePayloadParsers, ComputePayloadV1, ComputeRegistry, ComputeStatus, ConditionEvaluationCause, ConditionEvaluationOptions, ConditionEvaluationReport, ConditionEvaluationReportLevel, ConditionEvaluationReportTag, ConditionEvaluatorReporter, GateEngineRegistry, GateOutcome, GateOutcomeData, GatePayload, GatePayloadParser, GatePayloadParserRegistry, GatePayloadParsers, GatePayloadV1, GateStatus, GateTraceLeafSnapshot, GateTraceNodeSnapshot, GateViolationTrace, PolicyContext, PolicyViolation, VersionedComputeEngine, VersionedGateEngine };

package/dist/policies/engines/v1/gate/index.cjs

@@ -0,0 +1,91 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_gate_v1_payload_schema = require("../../../../gate-v1-payload.schema.cjs");
+const require_result = require("../../../../result.cjs");
+const require_outcome = require("../../../../outcome.cjs");
+//#region src/core/policies/engines/v1/gate/gate-engine-v1.ts
+var GateEngineV1 = class {
+	constructor(params = {}) {
+		this.version = 1;
+		this.coreConfig = params.coreConfig ?? require_gate_v1_payload_schema.coreConfig;
+	}
+	allow() {
+		return require_result.Result.ok(require_outcome.Outcome.of("ALLOW", { violations: [] }));
+	}
+	deny(violation) {
+		return require_result.Result.ok(require_outcome.Outcome.of("DENY", { violations: [violation] }));
+	}
+	outcomeFromStatus(status, violation) {
+		return status === "ALLOW" ? this.allow() : this.deny(violation);
+	}
+	isLeafNode(node) {
+		return "field" in node && "op" in node;
+	}
+	toLeafSnapshot(node) {
+		return {
+			kind: "LEAF",
+			field: node.field,
+			op: node.op,
+			...node.allowNull === true ? { allowNull: true } : {}
+		};
+	}
+	toNodeSnapshot(node) {
+		if (this.isLeafNode(node)) return this.toLeafSnapshot(node);
+		if ("and" in node) return {
+			kind: "AND",
+			childCount: node.and.length
+		};
+		if ("or" in node) return {
+			kind: "OR",
+			childCount: node.or.length
+		};
+		return { kind: "NOT" };
+	}
+	buildDenyViolation(conditionResult) {
+		return {
+			code: "DENY_CONDITION_MET",
+			message: `Gate denied at ${conditionResult.trace.conditionPath}`,
+			trace: {
+				conditionPath: conditionResult.trace.conditionPath,
+				decisiveNode: this.toNodeSnapshot(conditionResult.trace.decisiveNode),
+				lastEvaluatedLeaf: this.toLeafSnapshot(conditionResult.trace.lastEvaluatedLeaf),
+				lastEvaluatedLeafPath: conditionResult.trace.lastEvaluatedLeafPath,
+				lastEvaluatedLeafResult: conditionResult.trace.lastEvaluatedLeafResult,
+				field: conditionResult.trace.lastEvaluatedLeaf.field,
+				op: conditionResult.trace.lastEvaluatedLeaf.op
+			}
+		};
+	}
+	normalizePayload(payload) {
+		if ("condition" in payload) return {
+			allowIf: payload.condition,
+			defaultOutcome: "DENY"
+		};
+		return payload;
+	}
+	/**
+	* Evaluates a GATE payload against a context object.
+	* Pure function — no side effects.
+	*
+	* Receives an already-parsed `GatePayload`; the registry is responsible
+	* for parsing from raw `unknown` before calling this method.
+	* Returns Result for technical failures (condition evaluation errors).
+	* The Outcome inside carries the business decision (ALLOW/DENY).
+	*/
+	evaluate(payload, context) {
+		const gatePayload = this.normalizePayload(payload);
+		const isAllowedResult = new require_gate_v1_payload_schema.ConditionEvaluatorV1(context, this.coreConfig.getConditionEvaluationOptions(this.version)).evaluateWithTrace(gatePayload.allowIf);
+		if (isAllowedResult.isErr()) return require_result.Result.err(isAllowedResult.errorOrNull());
+		const isAllowed = isAllowedResult.getOrNull();
+		if (isAllowed.matched) return this.allow();
+		return this.outcomeFromStatus(gatePayload.defaultOutcome, this.buildDenyViolation(isAllowed));
+	}
+};
+//#endregion
+exports.ConditionEvaluatorV1 = require_gate_v1_payload_schema.ConditionEvaluatorV1;
+exports.GateEngineV1 = GateEngineV1;
+exports.GatePayloadSchemaV1 = require_gate_v1_payload_schema.GatePayloadSchemaV1;
+exports.conditionLeafNodeSchema = require_gate_v1_payload_schema.conditionLeafNodeSchema;
+exports.conditionNodeSchema = require_gate_v1_payload_schema.conditionNodeSchema;
+exports.gatePayloadSchema = require_gate_v1_payload_schema.gatePayloadSchema;
+
+//# sourceMappingURL=index.cjs.map

package/dist/policies/engines/v1/gate/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["coreConfig","Result","Outcome","ConditionEvaluatorV1"],"sources":["../../../../../src/core/policies/engines/v1/gate/gate-engine-v1.ts"],"sourcesContent":["import { type CoreConfig, coreConfig } from \"../../../../config/index.js\";\nimport { Outcome } from \"../../../../result/outcome.js\";\nimport { Result } from \"../../../../result/result.js\";\n\nimport {\n    ConditionEvaluatorV1,\n    type TracedConditionEvaluation,\n} from \"../condition-evaluator.js\";\nimport type { ConditionLeafNode, ConditionNode } from \"../condition-types.js\";\nimport type { GatePayload } from \"../../gate-payload.js\";\nimport type {\n    GateOutcome,\n    GateStatus,\n    GateTraceLeafSnapshot,\n    GateTraceNodeSnapshot,\n    PolicyContext,\n    PolicyViolation,\n    VersionedGateEngine,\n} from \"../../gate-types.js\";\n\n// ─── Gate engine v1 ─────────────────────────────────────────────────────────\n\nexport class GateEngineV1 implements VersionedGateEngine {\n    public readonly version = 1;\n    private readonly coreConfig: CoreConfig;\n\n    constructor(params: { readonly coreConfig?: CoreConfig } = {}) {\n        this.coreConfig = params.coreConfig ?? coreConfig;\n    }\n\n    private allow(): Result<GateOutcome, string> {\n        return Result.ok(Outcome.of(\"ALLOW\", { violations: [] }));\n    }\n\n    private deny(violation: PolicyViolation): Result<GateOutcome, string> {\n        return Result.ok(\n            Outcome.of(\"DENY\", {\n                violations: [violation],\n            }),\n        );\n    }\n\n    private outcomeFromStatus(\n        status: GateStatus,\n        violation: PolicyViolation,\n    ): Result<GateOutcome, string> {\n        return status === \"ALLOW\" ? this.allow() : this.deny(violation);\n    }\n\n    private isLeafNode(node: ConditionNode): node is ConditionLeafNode {\n        return \"field\" in node && \"op\" in node;\n    }\n\n    private toLeafSnapshot(node: ConditionLeafNode): GateTraceLeafSnapshot {\n        return {\n            kind: \"LEAF\",\n            field: node.field,\n            op: node.op,\n            ...(node.allowNull === true ? { allowNull: true } : {}),\n        };\n    }\n\n    private toNodeSnapshot(node: ConditionNode): GateTraceNodeSnapshot {\n        if (this.isLeafNode(node)) {\n            return this.toLeafSnapshot(node);\n        }\n\n        if (\"and\" in node) {\n            return {\n                kind: \"AND\",\n                childCount: node.and.length,\n            };\n        }\n\n        if (\"or\" in node) {\n            return {\n                kind: \"OR\",\n                childCount: node.or.length,\n            };\n        }\n\n        return {\n            kind: \"NOT\",\n        };\n    }\n\n    private buildDenyViolation(\n        conditionResult: TracedConditionEvaluation,\n    ): PolicyViolation {\n        return {\n            code: \"DENY_CONDITION_MET\",\n            message: `Gate denied at ${conditionResult.trace.conditionPath}`,\n            trace: {\n                conditionPath: conditionResult.trace.conditionPath,\n                decisiveNode: this.toNodeSnapshot(\n                    conditionResult.trace.decisiveNode,\n                ),\n                lastEvaluatedLeaf: this.toLeafSnapshot(\n                    conditionResult.trace.lastEvaluatedLeaf,\n                ),\n                lastEvaluatedLeafPath:\n                    conditionResult.trace.lastEvaluatedLeafPath,\n                lastEvaluatedLeafResult:\n                    conditionResult.trace.lastEvaluatedLeafResult,\n                field: conditionResult.trace.lastEvaluatedLeaf.field,\n                op: conditionResult.trace.lastEvaluatedLeaf.op,\n            },\n        };\n    }\n\n    private normalizePayload(payload: GatePayload): {\n        readonly allowIf: ConditionNode;\n        readonly defaultOutcome: \"ALLOW\" | \"DENY\";\n    } {\n        if (\"condition\" in payload) {\n            return {\n                allowIf: payload.condition,\n                defaultOutcome: \"DENY\",\n            };\n        }\n\n        return payload;\n    }\n\n    /**\n     * Evaluates a GATE payload against a context object.\n     * Pure function — no side effects.\n     *\n     * Receives an already-parsed `GatePayload`; the registry is responsible\n     * for parsing from raw `unknown` before calling this method.\n     * Returns Result for technical failures (condition evaluation errors).\n     * The Outcome inside carries the business decision (ALLOW/DENY).\n     */\n    evaluate(\n        payload: GatePayload,\n        context: PolicyContext,\n    ): Result<GateOutcome, string> {\n        const gatePayload = this.normalizePayload(payload);\n        const conditionEvaluator = new ConditionEvaluatorV1(\n            context,\n            this.coreConfig.getConditionEvaluationOptions(this.version),\n        );\n\n        const isAllowedResult = conditionEvaluator.evaluateWithTrace(\n            gatePayload.allowIf,\n        );\n        if (isAllowedResult.isErr()) {\n            return Result.err(isAllowedResult.errorOrNull()!);\n        }\n\n        const isAllowed = isAllowedResult.getOrNull()!;\n        if (isAllowed.matched) {\n            return this.allow();\n        }\n\n        return this.outcomeFromStatus(\n            gatePayload.defaultOutcome,\n            this.buildDenyViolation(isAllowed),\n        );\n    }\n}\n"],"mappings":";;;;;AAsBA,IAAa,eAAb,MAAyD;CAIrD,YAAY,SAA+C,CAAC,GAAG;iBAHrC;EAItB,KAAK,aAAa,OAAO,cAAcA,+BAAAA;CAC3C;CAEA,QAA6C;EACzC,OAAOC,eAAAA,OAAO,GAAGC,gBAAAA,QAAQ,GAAG,SAAS,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;CAC5D;CAEA,KAAa,WAAyD;EAClE,OAAOD,eAAAA,OAAO,GACVC,gBAAAA,QAAQ,GAAG,QAAQ,EACf,YAAY,CAAC,SAAS,EAC1B,CAAC,CACL;CACJ;CAEA,kBACI,QACA,WAC2B;EAC3B,OAAO,WAAW,UAAU,KAAK,MAAM,IAAI,KAAK,KAAK,SAAS;CAClE;CAEA,WAAmB,MAAgD;EAC/D,OAAO,WAAW,QAAQ,QAAQ;CACtC;CAEA,eAAuB,MAAgD;EACnE,OAAO;GACH,MAAM;GACN,OAAO,KAAK;GACZ,IAAI,KAAK;GACT,GAAI,KAAK,cAAc,OAAO,EAAE,WAAW,KAAK,IAAI,CAAC;EACzD;CACJ;CAEA,eAAuB,MAA4C;EAC/D,IAAI,KAAK,WAAW,IAAI,GACpB,OAAO,KAAK,eAAe,IAAI;EAGnC,IAAI,SAAS,MACT,OAAO;GACH,MAAM;GACN,YAAY,KAAK,IAAI;EACzB;EAGJ,IAAI,QAAQ,MACR,OAAO;GACH,MAAM;GACN,YAAY,KAAK,GAAG;EACxB;EAGJ,OAAO,EACH,MAAM,MACV;CACJ;CAEA,mBACI,iBACe;EACf,OAAO;GACH,MAAM;GACN,SAAS,kBAAkB,gBAAgB,MAAM;GACjD,OAAO;IACH,eAAe,gBAAgB,MAAM;IACrC,cAAc,KAAK,eACf,gBAAgB,MAAM,YAC1B;IACA,mBAAmB,KAAK,eACpB,gBAAgB,MAAM,iBAC1B;IACA,uBACI,gBAAgB,MAAM;IAC1B,yBACI,gBAAgB,MAAM;IAC1B,OAAO,gBAAgB,MAAM,kBAAkB;IAC/C,IAAI,gBAAgB,MAAM,kBAAkB;GAChD;EACJ;CACJ;CAEA,iBAAyB,SAGvB;EACE,IAAI,eAAe,SACf,OAAO;GACH,SAAS,QAAQ;GACjB,gBAAgB;EACpB;EAGJ,OAAO;CACX;;;;;;;;;;CAWA,SACI,SACA,SAC2B;EAC3B,MAAM,cAAc,KAAK,iBAAiB,OAAO;EAMjD,MAAM,kBAAkB,IALOC,+BAAAA,qBAC3B,SACA,KAAK,WAAW,8BAA8B,KAAK,OAAO,CAGrB,EAAE,kBACvC,YAAY,OAChB;EACA,IAAI,gBAAgB,MAAM,GACtB,OAAOF,eAAAA,OAAO,IAAI,gBAAgB,YAAY,CAAE;EAGpD,MAAM,YAAY,gBAAgB,UAAU;EAC5C,IAAI,UAAU,SACV,OAAO,KAAK,MAAM;EAGtB,OAAO,KAAK,kBACR,YAAY,gBACZ,KAAK,mBAAmB,SAAS,CACrC;CACJ;AACJ"}

package/dist/policies/engines/v1/gate/index.d.cts

@@ -0,0 +1,121 @@
+import { a as Result } from "../../../../outcome.cjs";
+import { D as ConditionEvaluationOptions, d as GatePayloadV1, f as ConditionLeafNode, l as VersionedGateEngine, m as CoreConfig, p as ConditionNode, s as PolicyContext, t as GateOutcome, u as GatePayload } from "../../../../gate-types.cjs";
+import { z } from "zod";
+
+//#region src/core/policies/engines/v1/condition-evaluator.d.ts
+interface ConditionEvaluationTrace {
+  readonly conditionPath: string;
+  readonly decisiveNode: ConditionNode;
+  readonly lastEvaluatedLeaf: ConditionLeafNode;
+  readonly lastEvaluatedLeafPath: string;
+  readonly lastEvaluatedLeafResult: boolean;
+}
+interface TracedConditionEvaluation {
+  readonly matched: boolean;
+  readonly trace: ConditionEvaluationTrace;
+}
+declare class ConditionEvaluatorV1 {
+  private readonly context;
+  private readonly options;
+  constructor(context: PolicyContext, options: ConditionEvaluationOptions);
+  private static isLeafNode;
+  private static isAndNode;
+  private static isOrNode;
+  private static isNotNode;
+  private static isRelationalOperator;
+  private static describeError;
+  private static buildNullishNumericOperandMessage;
+  private static buildNullishDateOperandMessage;
+  private static buildInvalidDateOperandMessage;
+  private static buildInvalidNumericOperandMessage;
+  private static buildInvalidSetOperandMessage;
+  private static buildEmptyOrConditionMessage;
+  private static buildEmptyAndConditionMessage;
+  private static parseComparableDate;
+  private static evaluateRelationalNumbers;
+  private buildReport;
+  private conditionEvalErr;
+  private reportDateOperandError;
+  private reportInvalidNumericOperand;
+  private reportInvalidSetOperand;
+  private evaluateDateRelationalNode;
+  private evaluateOperator;
+  private evaluateNumericRelationalNode;
+  private evaluateLeafNode;
+  private buildTrace;
+  private evaluateWithTraceInternal;
+  evaluate(node: ConditionNode): Result<boolean, string>;
+  evaluateWithTrace(node: ConditionNode): Result<TracedConditionEvaluation, string>;
+  static extractFields(node: ConditionNode): string[];
+}
+//#endregion
+//#region src/core/policies/engines/v1/gate/gate-engine-v1.d.ts
+declare class GateEngineV1 implements VersionedGateEngine {
+  readonly version = 1;
+  private readonly coreConfig;
+  constructor(params?: {
+    readonly coreConfig?: CoreConfig;
+  });
+  private allow;
+  private deny;
+  private outcomeFromStatus;
+  private isLeafNode;
+  private toLeafSnapshot;
+  private toNodeSnapshot;
+  private buildDenyViolation;
+  private normalizePayload;
+  /**
+   * Evaluates a GATE payload against a context object.
+   * Pure function — no side effects.
+   *
+   * Receives an already-parsed `GatePayload`; the registry is responsible
+   * for parsing from raw `unknown` before calling this method.
+   * Returns Result for technical failures (condition evaluation errors).
+   * The Outcome inside carries the business decision (ALLOW/DENY).
+   */
+  evaluate(payload: GatePayload, context: PolicyContext): Result<GateOutcome, string>;
+}
+//#endregion
+//#region src/core/policies/engines/v1/condition-schema.d.ts
+declare const conditionLeafNodeSchema: z.ZodType<ConditionLeafNode>;
+declare const conditionNodeSchema: z.ZodType<ConditionNode>;
+//#endregion
+//#region src/core/policies/engines/v1/gate/gate-v1-payload.schema.d.ts
+declare class GatePayloadSchemaV1 {
+  static readonly schema: z.ZodUnion<[z.ZodObject<{
+    condition: z.ZodType<ConditionNode, z.ZodTypeDef, ConditionNode>;
+  }, "strict", z.ZodTypeAny, {
+    condition: ConditionNode;
+  }, {
+    condition: ConditionNode;
+  }>, z.ZodObject<{
+    allowIf: z.ZodType<ConditionNode, z.ZodTypeDef, ConditionNode>;
+    defaultOutcome: z.ZodEnum<["ALLOW", "DENY"]>;
+  }, "strict", z.ZodTypeAny, {
+    allowIf: ConditionNode;
+    defaultOutcome: "ALLOW" | "DENY";
+  }, {
+    allowIf: ConditionNode;
+    defaultOutcome: "ALLOW" | "DENY";
+  }>]>;
+  static parse(payload: unknown): Result<GatePayloadV1, string>;
+}
+declare const gatePayloadSchema: z.ZodUnion<[z.ZodObject<{
+  condition: z.ZodType<ConditionNode, z.ZodTypeDef, ConditionNode>;
+}, "strict", z.ZodTypeAny, {
+  condition: ConditionNode;
+}, {
+  condition: ConditionNode;
+}>, z.ZodObject<{
+  allowIf: z.ZodType<ConditionNode, z.ZodTypeDef, ConditionNode>;
+  defaultOutcome: z.ZodEnum<["ALLOW", "DENY"]>;
+}, "strict", z.ZodTypeAny, {
+  allowIf: ConditionNode;
+  defaultOutcome: "ALLOW" | "DENY";
+}, {
+  allowIf: ConditionNode;
+  defaultOutcome: "ALLOW" | "DENY";
+}>]>;
+//#endregion
+export { ConditionEvaluatorV1, GateEngineV1, GatePayloadSchemaV1, GatePayloadV1, conditionLeafNodeSchema, conditionNodeSchema, gatePayloadSchema };
+//# sourceMappingURL=index.d.cts.map

package/dist/policies/index.cjs

@@ -0,0 +1,41 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_gate_v1_payload_schema = require("../gate-v1-payload.schema.cjs");
+const require_result = require("../result.cjs");
+const require_outcome = require("../outcome.cjs");
+const require_policy_service = require("../policy-service.cjs");
+const require_gate_engine_registry = require("../gate-engine-registry.cjs");
+exports.ComputeEngineRegistry = require_gate_engine_registry.ComputeEngineRegistry;
+exports.ComputeEvaluatorRegistry = require_gate_engine_registry.ComputeEvaluatorRegistry;
+exports.ComputePayloadParserRegistry = require_gate_engine_registry.ComputePayloadParserRegistry;
+exports.ComputePayloadParsers = require_gate_engine_registry.ComputePayloadParsers;
+exports.ComputeRegistry = require_gate_engine_registry.ComputeRegistry;
+exports.ContextResolverRegistry = require_policy_service.ContextResolverRegistry;
+exports.ContextSeedValidator = require_policy_service.ContextSeedValidator;
+exports.CoreConfig = require_gate_v1_payload_schema.CoreConfig;
+exports.Err = require_result.Err;
+exports.GateEngineRegistry = require_gate_engine_registry.GateEngineRegistry;
+exports.GatePayloadParsers = require_gate_engine_registry.GatePayloadParsers;
+exports.InMemoryPolicyDefinitionRepository = require_policy_service.InMemoryPolicyDefinitionRepository;
+exports.Ok = require_result.Ok;
+exports.Outcome = require_outcome.Outcome;
+exports.PolicyAsOfResolver = require_policy_service.PolicyAsOfResolver;
+exports.PolicyCatalog = require_policy_service.PolicyCatalog;
+exports.PolicyCatalogFactory = require_policy_service.PolicyCatalogFactory;
+exports.PolicyContextBuilder = require_policy_service.PolicyContextBuilder;
+exports.PolicyContextPath = require_gate_v1_payload_schema.PolicyContextPath;
+exports.PolicyDefinition = require_policy_service.PolicyDefinition;
+exports.PolicyEvaluationErrors = require_policy_service.PolicyEvaluationErrors;
+exports.PolicyHashing = require_policy_service.PolicyHashing;
+exports.PolicyKey = require_policy_service.PolicyKey;
+exports.PolicyResolver = require_policy_service.PolicyResolver;
+exports.PolicyScopeMatcher = require_policy_service.PolicyScopeMatcher;
+exports.PolicyService = require_policy_service.PolicyService;
+exports.Result = require_result.Result;
+exports.asPolicyDecisionId = require_policy_service.asPolicyDecisionId;
+exports.asPolicyDefinitionId = require_policy_service.asPolicyDefinitionId;
+exports.asSchoolId = require_policy_service.asSchoolId;
+exports.asTenantId = require_policy_service.asTenantId;
+exports.contextResolverRegistry = require_policy_service.contextResolverRegistry;
+exports.coreConfig = require_gate_v1_payload_schema.coreConfig;
+exports.registerNamespacedContextResolvers = require_policy_service.registerNamespacedContextResolvers;
+exports.registerNamespacedContextResolversIn = require_policy_service.registerNamespacedContextResolversIn;

package/dist/policies/index.d.cts

@@ -0,0 +1,7 @@
+import { a as Result, i as Ok, n as Outcome, r as Err, t as CommonOutcomeStatus } from "../outcome.cjs";
+import { A as ConditionEvaluationReportTag, C as asPolicyDefinitionId, D as ConditionEvaluationOptions, E as ConditionEvaluationCause, O as ConditionEvaluationReport, S as asPolicyDecisionId, T as asTenantId, a as GateTraceNodeSnapshot, b as SchoolId, c as PolicyViolation, g as CoreObservabilityConfig, h as CoreConfigOptions, i as GateTraceLeafSnapshot, j as ConditionEvaluatorReporter, k as ConditionEvaluationReportLevel, l as VersionedGateEngine, m as CoreConfig, n as GateOutcomeData, o as GateViolationTrace, r as GateStatus, s as PolicyContext, t as GateOutcome, u as GatePayload, v as PolicyDecisionId, w as asSchoolId, x as TenantId, y as PolicyDefinitionId } from "../gate-types.cjs";
+import { a as PolicyPackage, c as coreConfig, i as PolicyCatalogFactory, n as contextResolverRegistry, o as InMemoryPolicyDefinitionRepository, r as registerNamespacedContextResolvers, s as PolicyHashing, t as PolicyContextPath } from "../path.cjs";
+import { A as PolicyScope, C as BasePolicyDefinitionProps, D as PolicyDefinition, E as GatePolicyDefinitionProps, F as PolicyKey, I as AsOfSource, L as PolicyKind, M as ScopeChain, N as PolicyCatalog, O as PolicyDefinitionProps, P as PolicyCatalogEntryProps, R as PolicyOwner, T as FindCandidatesParams, _ as ContextResolverResilienceOptions, a as PolicyServiceOptions, b as ContextSeed, c as PolicyEvaluationErrors, d as PolicyAsOfResolver, f as PolicyContextBuilder, g as ContextResolverCircuitBreakerOptions, h as registerNamespacedContextResolversIn, i as PolicyService, j as PolicyScopeMatcher, k as PolicyDefinitionStatus, l as PolicyResolver, m as ContextResolverRegistry, n as PolicyDecision, o as PolicyServiceParams, p as PolicyContextBuilderOptions, r as PolicyEvaluationResult, s as PolicyEvaluationError, t as EvaluateInput, u as DeriveAsOfOptions, v as ContextResolverRetryOptions, w as ComputePolicyDefinitionProps, x as ContextSeedValidator, y as ContextValueResolver, z as PolicyScopeLevel } from "../policy-service.cjs";
+import { a as ComputeOutcome, c as VersionedComputeEngine, i as ComputeEvaluatorRegistration, n as ComputeRegistry, o as ComputeOutcomeData, r as ComputeEvaluator, s as ComputeStatus, t as GateEngineRegistry } from "../gate-engine-registry.cjs";
+import { a as ComputePayloadParserRegistry, c as ComputeEvaluatorRegistry, o as ComputePayloadParsers, r as GatePayloadParsers, s as ComputeEngineRegistry } from "../parse-gate-payload.cjs";
+export { AsOfSource, BasePolicyDefinitionProps, CommonOutcomeStatus, ComputeEngineRegistry, ComputeEvaluator, ComputeEvaluatorRegistration, ComputeEvaluatorRegistry, ComputeOutcome, ComputeOutcomeData, ComputePayloadParserRegistry, ComputePayloadParsers, ComputePolicyDefinitionProps, ComputeRegistry, ComputeStatus, ConditionEvaluationCause, ConditionEvaluationOptions, ConditionEvaluationReport, ConditionEvaluationReportLevel, ConditionEvaluationReportTag, ConditionEvaluatorReporter, ContextResolverCircuitBreakerOptions, ContextResolverRegistry, ContextResolverResilienceOptions, ContextResolverRetryOptions, ContextSeed, ContextSeedValidator, ContextValueResolver, CoreConfig, CoreConfigOptions, CoreObservabilityConfig, DeriveAsOfOptions, Err, EvaluateInput, FindCandidatesParams, GateEngineRegistry, GateOutcome, GateOutcomeData, GatePayload, GatePayloadParsers, GatePolicyDefinitionProps, GateStatus, GateTraceLeafSnapshot, GateTraceNodeSnapshot, GateViolationTrace, InMemoryPolicyDefinitionRepository, Ok, Outcome, PolicyAsOfResolver, PolicyCatalog, PolicyCatalogEntryProps, PolicyCatalogFactory, PolicyContext, PolicyContextBuilder, PolicyContextBuilderOptions, PolicyContextPath, PolicyDecision, PolicyDecisionId, PolicyDefinition, PolicyDefinitionId, PolicyDefinitionProps, PolicyDefinitionStatus, PolicyEvaluationError, PolicyEvaluationErrors, PolicyEvaluationResult, PolicyHashing, PolicyKey, PolicyKind, PolicyOwner, PolicyPackage, PolicyResolver, PolicyScope, PolicyScopeLevel, PolicyScopeMatcher, PolicyService, PolicyServiceOptions, PolicyServiceParams, PolicyViolation, Result, SchoolId, ScopeChain, TenantId, VersionedComputeEngine, VersionedGateEngine, asPolicyDecisionId, asPolicyDefinitionId, asSchoolId, asTenantId, contextResolverRegistry, coreConfig, registerNamespacedContextResolvers, registerNamespacedContextResolversIn };