@cullet/erp-core 1.0.0

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

@@ -0,0 +1,3 @@
+import { A as ConditionEvaluationReport, M as ConditionEvaluationReportTag, N as ConditionEvaluatorReporter, O as ConditionEvaluationCause, a as GateTraceNodeSnapshot, c as PolicyViolation, d as GatePayloadV1, i as GateTraceLeafSnapshot, j as ConditionEvaluationReportLevel, k as ConditionEvaluationOptions, l as VersionedGateEngine, n as GateOutcomeData, o as GateViolationTrace, r as GateStatus, s as PolicyContext, t as GateOutcome, u as GatePayload } from "../../gate-types.js";
+import { _ as ComputePayload, a as ComputePayloadParserRegistry, b as ComputeParamsPayload, c as ComputeRegistry, d as ComputeEvaluator, f as ComputeEvaluatorRegistration, g as VersionedComputeEngine, h as ComputeStatus, i as ComputePayloadParser, l as ComputeEngineRegistry, m as ComputeOutcomeData, n as GatePayloadParserRegistry, o as ComputePayloadParsers, p as ComputeOutcome, r as GatePayloadParsers, s as GateEngineRegistry, t as GatePayloadParser, u as ComputeEvaluatorRegistry, v as ComputeDecisionTablePayload, x as ComputePayloadV1, y as ComputeDecisionTableRule } from "../../parse-gate-payload.js";
+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/index.js

@@ -0,0 +1,2 @@
+import { a as ComputeEvaluatorRegistry, c as ComputePayloadParsers, i as ComputeRegistry, n as GatePayloadParserRegistry, o as ComputeEngineRegistry, r as GatePayloadParsers, s as ComputePayloadParserRegistry, t as GateEngineRegistry } from "../../gate-engine-registry.js";
+export { ComputeEngineRegistry, ComputeEvaluatorRegistry, ComputePayloadParserRegistry, ComputePayloadParsers, ComputeRegistry, GateEngineRegistry, GatePayloadParserRegistry, GatePayloadParsers };

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

@@ -0,0 +1,115 @@
+import { I as Result, d as GatePayloadV1, f as ConditionLeafNode, g as CoreConfig, k as ConditionEvaluationOptions, l as VersionedGateEngine, p as ConditionNode, s as PolicyContext, t as GateOutcome, u as GatePayload } from "../../../../gate-types.js";
+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 buildEmptyOrConditionMessage;
+  private static parseComparableDate;
+  private static evaluateRelationalNumbers;
+  private buildReport;
+  private conditionEvalErr;
+  private reportDateOperandError;
+  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.ts.map

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

@@ -0,0 +1,84 @@
+import { a as conditionNodeSchema, i as conditionLeafNodeSchema, l as Result, n as gatePayloadSchema, r as ConditionEvaluatorV1, t as GatePayloadSchemaV1, u as coreConfig } from "../../../../gate-v1-payload.schema.js";
+import { t as Outcome } from "../../../../outcome.js";
+//#region src/core/policies/engines/v1/gate/gate-engine-v1.ts
+var GateEngineV1 = class {
+	constructor(params = {}) {
+		this.version = 1;
+		this.coreConfig = params.coreConfig ?? coreConfig;
+	}
+	allow() {
+		return Result.ok(Outcome.of("ALLOW", { violations: [] }));
+	}
+	deny(violation) {
+		return Result.ok(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 ConditionEvaluatorV1(context, this.coreConfig.getConditionEvaluationOptions(this.version)).evaluateWithTrace(gatePayload.allowIf);
+		if (isAllowedResult.isErr()) return Result.err(isAllowedResult.errorOrNull());
+		const isAllowed = isAllowedResult.getOrNull();
+		if (isAllowed.matched) return this.allow();
+		return this.outcomeFromStatus(gatePayload.defaultOutcome, this.buildDenyViolation(isAllowed));
+	}
+};
+//#endregion
+export { ConditionEvaluatorV1, GateEngineV1, GatePayloadSchemaV1, conditionLeafNodeSchema, conditionNodeSchema, gatePayloadSchema };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../src/core/policies/engines/v1/gate/gate-engine-v1.ts"],"sourcesContent":["import { type CoreConfig, coreConfig } from \"../../../../config\";\nimport { Outcome } from \"../../../../result/outcome\";\nimport { Result } from \"../../../../result/result\";\n\nimport {\n  ConditionEvaluatorV1,\n  type TracedConditionEvaluation,\n} from \"../condition-evaluator\";\nimport type { ConditionLeafNode, ConditionNode } from \"../condition-types\";\nimport type { GatePayload } from \"../../gate-payload\";\nimport type {\n  GateOutcome,\n  GateStatus,\n  GateTraceLeafSnapshot,\n  GateTraceNodeSnapshot,\n  PolicyContext,\n  PolicyViolation,\n  VersionedGateEngine,\n} from \"../../gate-types\";\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(conditionResult.trace.decisiveNode),\n        lastEvaluatedLeaf: this.toLeafSnapshot(\n          conditionResult.trace.lastEvaluatedLeaf,\n        ),\n        lastEvaluatedLeafPath: conditionResult.trace.lastEvaluatedLeafPath,\n        lastEvaluatedLeafResult: 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;CAIvD,YAAY,SAA+C,CAAC,GAAG;iBAHrC;EAIxB,KAAK,aAAa,OAAO,cAAc;CACzC;CAEA,QAA6C;EAC3C,OAAO,OAAO,GAAG,QAAQ,GAAG,SAAS,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;CAC1D;CAEA,KAAa,WAAyD;EACpE,OAAO,OAAO,GACZ,QAAQ,GAAG,QAAQ,EACjB,YAAY,CAAC,SAAS,EACxB,CAAC,CACH;CACF;CAEA,kBACE,QACA,WAC6B;EAC7B,OAAO,WAAW,UAAU,KAAK,MAAM,IAAI,KAAK,KAAK,SAAS;CAChE;CAEA,WAAmB,MAAgD;EACjE,OAAO,WAAW,QAAQ,QAAQ;CACpC;CAEA,eAAuB,MAAgD;EACrE,OAAO;GACL,MAAM;GACN,OAAO,KAAK;GACZ,IAAI,KAAK;GACT,GAAI,KAAK,cAAc,OAAO,EAAE,WAAW,KAAK,IAAI,CAAC;EACvD;CACF;CAEA,eAAuB,MAA4C;EACjE,IAAI,KAAK,WAAW,IAAI,GACtB,OAAO,KAAK,eAAe,IAAI;EAGjC,IAAI,SAAS,MACX,OAAO;GACL,MAAM;GACN,YAAY,KAAK,IAAI;EACvB;EAGF,IAAI,QAAQ,MACV,OAAO;GACL,MAAM;GACN,YAAY,KAAK,GAAG;EACtB;EAGF,OAAO,EACL,MAAM,MACR;CACF;CAEA,mBACE,iBACiB;EACjB,OAAO;GACL,MAAM;GACN,SAAS,kBAAkB,gBAAgB,MAAM;GACjD,OAAO;IACL,eAAe,gBAAgB,MAAM;IACrC,cAAc,KAAK,eAAe,gBAAgB,MAAM,YAAY;IACpE,mBAAmB,KAAK,eACtB,gBAAgB,MAAM,iBACxB;IACA,uBAAuB,gBAAgB,MAAM;IAC7C,yBAAyB,gBAAgB,MAAM;IAC/C,OAAO,gBAAgB,MAAM,kBAAkB;IAC/C,IAAI,gBAAgB,MAAM,kBAAkB;GAC9C;EACF;CACF;CAEA,iBAAyB,SAGvB;EACA,IAAI,eAAe,SACjB,OAAO;GACL,SAAS,QAAQ;GACjB,gBAAgB;EAClB;EAGF,OAAO;CACT;;;;;;;;;;CAWA,SACE,SACA,SAC6B;EAC7B,MAAM,cAAc,KAAK,iBAAiB,OAAO;EAMjD,MAAM,kBAAkB,IALO,qBAC7B,SACA,KAAK,WAAW,8BAA8B,KAAK,OAAO,CAGnB,EAAE,kBACzC,YAAY,OACd;EACA,IAAI,gBAAgB,MAAM,GACxB,OAAO,OAAO,IAAI,gBAAgB,YAAY,CAAE;EAGlD,MAAM,YAAY,gBAAgB,UAAU;EAC5C,IAAI,UAAU,SACZ,OAAO,KAAK,MAAM;EAGpB,OAAO,KAAK,kBACV,YAAY,gBACZ,KAAK,mBAAmB,SAAS,CACnC;CACF;AACF"}

package/dist/policies/index.d.ts

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

package/dist/policies/index.js

@@ -0,0 +1,5 @@
+import { c as Ok, d as CoreConfig, l as Result, o as PolicyContextPath, s as Err, u as coreConfig } from "../gate-v1-payload.schema.js";
+import { t as Outcome } from "../outcome.js";
+import { _ as asPolicyDecisionId, a as ContextSeedValidator, b as asTenantId, c as ContextResolverRegistry, d as PolicyDefinition, f as InMemoryPolicyDefinitionRepository, g as PolicyCatalog, h as PolicyCatalogFactory, i as PolicyAsOfResolver, l as registerNamespacedContextResolversIn, m as PolicyKey, n as PolicyEvaluationErrors, o as contextResolverRegistry, p as PolicyScopeMatcher, r as PolicyResolver, s as registerNamespacedContextResolvers, t as PolicyService, u as PolicyContextBuilder, v as asPolicyDefinitionId, x as PolicyHashing, y as asSchoolId } from "../policy-service.js";
+import { a as ComputeEvaluatorRegistry, c as ComputePayloadParsers, i as ComputeRegistry, o as ComputeEngineRegistry, r as GatePayloadParsers, s as ComputePayloadParserRegistry, t as GateEngineRegistry } from "../gate-engine-registry.js";
+export { ComputeEngineRegistry, ComputeEvaluatorRegistry, ComputePayloadParserRegistry, ComputePayloadParsers, ComputeRegistry, ContextResolverRegistry, ContextSeedValidator, CoreConfig, Err, GateEngineRegistry, GatePayloadParsers, InMemoryPolicyDefinitionRepository, Ok, Outcome, PolicyAsOfResolver, PolicyCatalog, PolicyCatalogFactory, PolicyContextBuilder, PolicyContextPath, PolicyDefinition, PolicyEvaluationErrors, PolicyHashing, PolicyKey, PolicyResolver, PolicyScopeMatcher, PolicyService, Result, asPolicyDecisionId, asPolicyDefinitionId, asSchoolId, asTenantId, contextResolverRegistry, coreConfig, registerNamespacedContextResolvers, registerNamespacedContextResolversIn };