@cullet/erp-core 1.0.0

package/dist/policy-service.d.ts

@@ -0,0 +1,541 @@
+import { C as TenantId, I as Result, S as SchoolId, b as PolicyDecisionId, g as CoreConfig, t as GateOutcome, u as GatePayload, x as PolicyDefinitionId, y as PolicyReporter } from "./gate-types.js";
+import { _ as ComputePayload, c as ComputeRegistry, f as ComputeEvaluatorRegistration, p as ComputeOutcome, s as GateEngineRegistry } from "./parse-gate-payload.js";
+
+//#region src/core/config/core-config.instance.d.ts
+
+/**
+ * Shared instance for the application composition root.
+ * Use `new CoreConfig()` for isolated runtimes, tests, or multi-tenant hosts.
+ *
+ * The default reporter is silent so the core has no runtime logging dependency.
+ * Hosts can swap in their own `PolicyReporter` via
+ * `coreConfig.configure({ observability: { reporter } })`.
+ */
+declare const coreConfig: CoreConfig;
+//#endregion
+//#region src/core/policies/utils/hash.d.ts
+/**
+ * Produces a deterministic SHA-256 hex digest of a canonical JSON representation.
+ * Object keys are sorted recursively so key order does not affect the hash.
+ * Array item order is preserved on purpose; callers that treat arrays as sets
+ * must normalize or sort them before hashing.
+ *
+ * Values that JSON.stringify would silently drop or coerce (undefined,
+ * non-finite numbers, functions, symbols, bigint) are rejected up-front to
+ * prevent semantically different payloads from collapsing to the same hash.
+ */
+declare class PolicyHashing {
+  static sha256(input: string): string;
+  private static assertHashable;
+  static canonicalJson(value: unknown): string;
+  static computePayloadHash(payload: unknown, policyKey: string, policyVersion: string): string;
+}
+//#endregion
+//#region src/core/policies/catalog/catalog-types.d.ts
+type PolicyKind = "GATE" | "COMPUTE";
+type PolicyOwner = "PLATFORM_OWNER" | "TENANT_ADMIN" | "SCHOOL_ADMIN";
+type PolicyScopeLevel = "GLOBAL" | "TENANT" | "SCHOOL";
+/**
+ * Defines where the "as of" date comes from for a given policy.
+ */
+type AsOfSource = "NOW" | "CALLER_PROVIDED";
+//#endregion
+//#region src/core/policies/catalog/policy-key.d.ts
+declare class PolicyKey {
+  readonly module: string;
+  readonly area: string;
+  readonly name: string;
+  private constructor();
+  static parse(raw: string): Result<PolicyKey, string>;
+  toString(): string;
+  equals(other: PolicyKey): boolean;
+}
+//#endregion
+//#region src/core/policies/catalog/policy-catalog-entry.d.ts
+/**
+ * Properties for creating a PolicyCatalogEntry.
+ */
+interface PolicyCatalogEntryProps {
+  readonly key: PolicyKey;
+  readonly kind: PolicyKind;
+  readonly gateEngineVersion?: number;
+  readonly computeEngineVersion?: number;
+  readonly payloadSchemaVersion?: number;
+  readonly owner: PolicyOwner;
+  readonly allowedScopes: readonly PolicyScopeLevel[];
+  readonly asOfSource: AsOfSource;
+  /** Paths the context must contain for this policy to be evaluable. */
+  readonly contextRequirements: readonly string[];
+  readonly tags?: readonly string[];
+  readonly description: string;
+}
+/**
+ * Represents a single entry in the Policy Catalog.
+ * Encapsulates metadata and validation logic for a policy.
+ */
+declare class PolicyCatalogEntry {
+  readonly key: PolicyKey;
+  readonly kind: PolicyKind;
+  readonly gateEngineVersion?: number;
+  readonly computeEngineVersion?: number;
+  readonly payloadSchemaVersion?: number;
+  readonly owner: PolicyOwner;
+  readonly allowedScopes: readonly PolicyScopeLevel[];
+  readonly asOfSource: AsOfSource;
+  readonly contextRequirements: readonly string[];
+  readonly tags: readonly string[];
+  readonly description: string;
+  constructor(props: PolicyCatalogEntryProps);
+  static assertFamilyConsistency(entries: readonly PolicyCatalogEntry[]): void;
+  static from(entry: PolicyCatalogEntry | PolicyCatalogEntryProps): PolicyCatalogEntry;
+  isGate(): boolean;
+  isCompute(): boolean;
+  allowsScope(scope: PolicyScopeLevel): boolean;
+  hasExplicitVersionSelector(): boolean;
+  matchesVersion(params: {
+    readonly kind: PolicyKind;
+    readonly gateEngineVersion?: number;
+    readonly computeEngineVersion?: number;
+    readonly payloadSchemaVersion?: number;
+  }): boolean;
+  toVariantKey(): string;
+  usesNowAsOf(): boolean;
+  usesCallerProvidedAsOf(): boolean;
+  requiresContext(path: string): boolean;
+  requiresAllContexts(paths: readonly string[]): boolean;
+  hasTag(tag: string): boolean;
+  equals(other: PolicyCatalogEntry): boolean;
+  toJSON(): PolicyCatalogEntryProps;
+}
+//#endregion
+//#region src/core/policies/catalog/policy-catalog.d.ts
+/**
+ * In-code catalog of all known policies.
+ * The catalog defines the universe of policies; the database cannot invent new ones.
+ */
+declare class PolicyCatalog {
+  private readonly versionedEntries;
+  private readonly entriesByKey;
+  constructor(entries: readonly PolicyCatalogEntry[]);
+  get(key: string): Result<PolicyCatalogEntry, string>;
+  getFamily(key: string): Result<readonly PolicyCatalogEntry[], string>;
+  getVersioned(params: {
+    readonly key: string;
+    readonly kind: "GATE" | "COMPUTE";
+    readonly gateEngineVersion?: number;
+    readonly computeEngineVersion?: number;
+    readonly payloadSchemaVersion?: number;
+  }): Result<PolicyCatalogEntry, string>;
+  list(): readonly PolicyCatalogEntry[];
+  has(key: string): boolean;
+}
+//#endregion
+//#region src/core/policies/defs/policy-payload.contracts.d.ts
+type AnyPolicyPayload = GatePayload | ComputePayload;
+/**
+ * Payload type associated with a policy key.
+ *
+ * Intentionally NOT backed by global module augmentation: two modules registering
+ * different shapes for the same literal key would silently override each other and
+ * the last `declare module` wins. Per-key payload typing must be expressed
+ * explicitly at the definition site (see {@link PolicyDefinition} type params).
+ */
+//#endregion
+//#region src/core/policies/defs/policy-scope.d.ts
+/**
+ * Scope attached to a PolicyDefinition — defines where it applies.
+ */
+interface PolicyScope {
+  readonly level: PolicyScopeLevel;
+  readonly tenantId: TenantId | null;
+  readonly schoolId: SchoolId | null;
+}
+/**
+ * Ordered list of scopes from most-specific to least-specific.
+ * Used by the resolver to match definitions.
+ *
+ * Example:
+ * ```
+ * [
+ *   { level: 'SCHOOL',  tenantId: 't1', schoolId: 's1' },
+ *   { level: 'TENANT',  tenantId: 't1', schoolId: null },
+ *   { level: 'GLOBAL',  tenantId: null, schoolId: null },
+ * ]
+ * ```
+ */
+type ScopeChain = readonly PolicyScope[];
+declare class PolicyScopeMatcher {
+  static weight(level: PolicyScopeLevel): number;
+  static matchesChain(defScope: PolicyScope, chain: ScopeChain): boolean;
+  static equals(a: PolicyScope, b: PolicyScope): boolean;
+}
+//#endregion
+//#region src/core/policies/defs/policy-definition.d.ts
+type PolicyDefinitionStatus = "DRAFT" | "PUBLISHED" | "RETIRED";
+interface BasePolicyDefinitionProps<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> {
+  readonly id: PolicyDefinitionId;
+  readonly policyKey: K;
+  readonly policyVersion: string;
+  readonly payloadSchemaVersion: number;
+  readonly contextVersionMin: number;
+  readonly contextVersionMax: number;
+  readonly enabled: boolean;
+  readonly status: PolicyDefinitionStatus;
+  readonly scope: PolicyScope;
+  readonly effectiveFrom: Date;
+  readonly effectiveTo: Date | null;
+  readonly priority: number;
+  readonly payloadJson: P;
+  readonly payloadHash: string;
+  readonly createdAt: Date;
+  readonly publishedAt: Date | null;
+}
+interface GatePolicyDefinitionProps<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> extends BasePolicyDefinitionProps<K, P> {
+  readonly kind: "GATE";
+  readonly gateEngineVersion: number;
+}
+interface ComputePolicyDefinitionProps<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> extends BasePolicyDefinitionProps<K, P> {
+  readonly kind: "COMPUTE";
+  readonly computeEngineVersion: number;
+}
+type GatePolicyDefinitionInput<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> = Omit<GatePolicyDefinitionProps<K, P>, "kind" | "enabled"> & {
+  readonly enabled?: boolean;
+};
+type ComputePolicyDefinitionInput<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> = Omit<ComputePolicyDefinitionProps<K, P>, "kind" | "enabled"> & {
+  readonly enabled?: boolean;
+};
+type PolicyDefinitionProps<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> = GatePolicyDefinitionProps<K, P> | ComputePolicyDefinitionProps<K, P>;
+declare class PolicyDefinition<K extends string = string, P extends AnyPolicyPayload = AnyPolicyPayload> {
+  private static assertPolicyVersionIsSemver;
+  readonly id: PolicyDefinitionId;
+  readonly policyKey: K;
+  readonly policyVersion: string;
+  readonly payloadSchemaVersion: number;
+  readonly contextVersionMin: number;
+  readonly contextVersionMax: number;
+  readonly gateEngineVersion?: number;
+  readonly computeEngineVersion?: number;
+  readonly enabled: boolean;
+  readonly status: PolicyDefinitionStatus;
+  readonly scope: PolicyScope;
+  readonly effectiveFrom: Date;
+  readonly effectiveTo: Date | null;
+  readonly priority: number;
+  readonly payloadJson: P;
+  readonly payloadHash: string;
+  readonly createdAt: Date;
+  readonly publishedAt: Date | null;
+  readonly kind: PolicyKind;
+  private constructor();
+  static gate<K extends string, P extends AnyPolicyPayload = AnyPolicyPayload>(props: GatePolicyDefinitionInput<K, P>): PolicyDefinition<K, P>;
+  static compute<K extends string, P extends AnyPolicyPayload = AnyPolicyPayload>(props: ComputePolicyDefinitionInput<K, P>): PolicyDefinition<K, P>;
+  isGate(): this is PolicyDefinition<K, P> & {
+    readonly kind: "GATE";
+    readonly gateEngineVersion: number;
+  };
+  isCompute(): this is PolicyDefinition<K, P> & {
+    readonly kind: "COMPUTE";
+    readonly computeEngineVersion: number;
+  };
+}
+interface FindCandidatesParams {
+  readonly policyKey: string;
+  readonly kind: PolicyKind;
+  readonly payloadSchemaVersion?: number;
+  readonly asOf: Date;
+  readonly contextVersion: number;
+  readonly scopeChain: readonly PolicyScope[];
+}
+//#endregion
+//#region src/core/policies/defs/policy-definition-repository.d.ts
+interface PolicyDefinitionRepository {
+  findCandidates(params: FindCandidatesParams): PolicyDefinition[];
+}
+//#endregion
+//#region src/core/policies/defs/in-memory-policy-definition-repo.d.ts
+declare class InMemoryPolicyDefinitionRepository implements PolicyDefinitionRepository {
+  private readonly definitions;
+  private readonly definitionsByPolicyKey;
+  constructor(definitions: readonly PolicyDefinition[]);
+  findCandidates(params: FindCandidatesParams): PolicyDefinition[];
+}
+//#endregion
+//#region src/core/policies/package/policy-package.d.ts
+/**
+ * Protocol of contribution: a module declares what it wants to add to the
+ * policy system without the core knowing which module it is.
+ *
+ * - catalogEntries: static policy descriptors the catalog will register.
+ * - definitions:   default policy definitions (rules/parameters) to seed.
+ * - evaluators:    compute evaluator registrations keyed by policy/version.
+ */
+interface PolicyPackage {
+  readonly catalogEntries: readonly PolicyCatalogEntryProps[];
+  readonly definitions: readonly PolicyDefinition[];
+  readonly evaluators: readonly ComputeEvaluatorRegistration[];
+}
+//#endregion
+//#region src/core/policies/catalog/catalog.instance.d.ts
+/**
+ * Aggregates catalog entries contributed by each module package into a single
+ * PolicyCatalog. The core knows nothing about concrete modules — callers
+ * are responsible for passing all relevant packages at composition time.
+ */
+declare class PolicyCatalogFactory {
+  static build(packages: readonly PolicyPackage[]): PolicyCatalog;
+}
+//#endregion
+//#region src/core/policies/context/context-seed.d.ts
+/**
+ * Seed data provided by the use case / caller.
+ * Contains raw IDs and inputs that the context system will resolve into paths.
+ * Each resolver is responsible for validating and extracting what it needs from fields.
+ */
+interface ContextSeed {
+  readonly tenantId: TenantId;
+  readonly schoolId: SchoolId;
+  readonly fields: Record<string, unknown>;
+}
+declare class ContextSeedValidator {
+  private static isBlankSeedId;
+  static validate(seed: ContextSeed): Result<ContextSeed, string>;
+}
+//#endregion
+//#region src/core/policies/context/context-resolver.d.ts
+interface ContextResolverRetryOptions {
+  readonly maxAttempts?: number;
+  readonly initialDelayMs?: number;
+  readonly maxDelayMs?: number;
+  readonly backoffMultiplier?: number;
+}
+interface ContextResolverCircuitBreakerOptions {
+  readonly failureThreshold?: number;
+  readonly cooldownMs?: number;
+}
+interface ContextResolverResilienceOptions {
+  readonly timeoutMs?: number;
+  readonly retry?: ContextResolverRetryOptions | false;
+  readonly circuitBreaker?: ContextResolverCircuitBreakerOptions | false;
+}
+/**
+ * A resolver that knows how to produce a value for a specific context path.
+ * Designed as async to allow future DB/API lookups without breaking the interface.
+ */
+interface ContextValueResolver {
+  readonly path: string;
+  readonly resilience?: ContextResolverResilienceOptions;
+  resolve(seed: ContextSeed): Promise<Result<unknown, string>>;
+}
+//#endregion
+//#region src/core/policies/context/context-registry.d.ts
+interface ContextResolverRegistrationOptions {
+  readonly namespace?: string;
+}
+/**
+ * Registry of context value resolvers, keyed by path.
+ */
+declare class ContextResolverRegistry {
+  private readonly resolvers;
+  register(resolver: ContextValueResolver, options?: ContextResolverRegistrationOptions): Result<void, string>;
+  registerAll(resolvers: readonly ContextValueResolver[], options?: ContextResolverRegistrationOptions): Result<void, string>;
+  get(path: string): ContextValueResolver | undefined;
+  has(path: string): boolean;
+  getNamespace(path: string): string | undefined;
+}
+declare function registerNamespacedContextResolversIn(registry: ContextResolverRegistry, namespace: string, resolvers: readonly ContextValueResolver[]): Result<ContextResolverRegistry, string>;
+//#endregion
+//#region src/core/policies/context/context-builder.d.ts
+interface PolicyContextBuilderOptions {
+  readonly defaultResolverResilience?: ContextResolverResilienceOptions;
+  readonly now?: () => number;
+  readonly sleep?: (delayMs: number) => Promise<void>;
+}
+/**
+ * Builds a context object by resolving required paths from a seed.
+ */
+declare class PolicyContextBuilder {
+  private readonly registry;
+  private readonly circuitStates;
+  private readonly defaultResolverResilience?;
+  private readonly now;
+  private readonly sleep;
+  constructor(registry: ContextResolverRegistry, options?: PolicyContextBuilderOptions);
+  private static clampPositiveInteger;
+  private static clampNonNegativeInteger;
+  private static normalizeTimeoutMs;
+  private static mergeRetryOptions;
+  private static mergeCircuitBreakerOptions;
+  private resolveResilienceOptions;
+  private getRetryDelayMs;
+  private resetCircuit;
+  private isCircuitOpen;
+  private recordResolverFailure;
+  private static describeThrownResolverError;
+  private resolveOnce;
+  private resolveWithResilience;
+  /**
+   * Resolves all required context paths and returns a flat context object.
+   * If any required path cannot be resolved, returns an error.
+   */
+  build(requirements: readonly string[], seed: ContextSeed): Promise<Result<Record<string, unknown>, string>>;
+}
+//#endregion
+//#region src/core/policies/context/context-registry.instance.d.ts
+/**
+ * Official instance of the ContextResolverRegistry.
+ * Use `new ContextResolverRegistry()` plus `registerNamespacedContextResolversIn`
+ * when each runtime/composition root needs its own isolated resolver graph.
+ */
+declare const contextResolverRegistry: ContextResolverRegistry;
+declare function registerNamespacedContextResolvers(namespace: string, resolvers: readonly ContextValueResolver[]): Result<ContextResolverRegistry, string>;
+//#endregion
+//#region src/core/policies/context/path.d.ts
+declare class PolicyContextPath {
+  private static readonly FORBIDDEN_SEGMENTS;
+  private static resolve;
+  private static parseSegments;
+  private static isPlainRecord;
+  static getOrAbsent(obj: Record<string, unknown>, path: string): Result<unknown, "absent">;
+  static has(obj: Record<string, unknown>, path: string): boolean;
+  static set(obj: Record<string, unknown>, path: string, value: unknown): Result<void, string>;
+}
+//#endregion
+//#region src/core/policies/asof/asof.d.ts
+interface DeriveAsOfOptions {
+  readonly maxFutureYears?: number;
+}
+declare class PolicyAsOfResolver {
+  private static resolveMaxFutureYears;
+  static derive(source: AsOfSource, seed: ContextSeed, now: Date, options?: DeriveAsOfOptions): Result<Date, string>;
+}
+//#endregion
+//#region src/core/policies/resolver/policy-resolver.d.ts
+/**
+ * Selects the best policy definition from a list of already-filtered candidates.
+ *
+ * Ordering criteria (highest priority first):
+ *   1. Scope specificity: SCHOOL (3) > TENANT (2) > GLOBAL (1)
+ *   2. Priority: higher number wins
+ *   3. publishedAt descending (fallback to createdAt)
+ *   4. Engine version descending (prefer-latest-engine-version — deterministic tiebreaker)
+ *   5. policyVersion descending (semver — final deterministic tiebreaker)
+ */
+declare class PolicyResolver {
+  resolveBest(candidates: readonly PolicyDefinition[]): Result<PolicyDefinition, string>;
+}
+//#endregion
+//#region src/core/policies/service/policy-evaluation-error.d.ts
+type PolicyEvaluationError = {
+  readonly kind: "INVALID_CONTEXT";
+  readonly stage: "SEED_VALIDATION" | "AS_OF_DERIVATION" | "CONTEXT_BUILD";
+  readonly policyKey: string;
+  readonly message: string;
+  readonly cause: string;
+} | {
+  readonly kind: "INVALID_POLICY_KEY";
+  readonly rawPolicyKey: string;
+  readonly message: string;
+  readonly cause: string;
+} | {
+  readonly kind: "POLICY_NOT_FOUND";
+  readonly policyKey: string;
+  readonly message: string;
+  readonly cause: string;
+} | {
+  readonly kind: "POLICY_DEFINITION_NOT_FOUND";
+  readonly policyKey: string;
+  readonly contextVersion: number;
+  readonly asOf: Date;
+  readonly message: string;
+  readonly cause: string;
+} | {
+  readonly kind: "POLICY_VARIANT_NOT_FOUND";
+  readonly policyKey: string;
+  readonly policyKind: PolicyKind;
+  readonly payloadSchemaVersion: number;
+  readonly gateEngineVersion?: number;
+  readonly computeEngineVersion?: number;
+  readonly message: string;
+  readonly cause: string;
+} | {
+  readonly kind: "ENGINE_FAILURE";
+  readonly policyKey: string;
+  readonly engine: PolicyKind;
+  readonly engineVersion: number;
+  readonly message: string;
+  readonly cause: string;
+};
+declare class PolicyEvaluationErrors {
+  static invalidContext(stage: Extract<PolicyEvaluationError, {
+    kind: "INVALID_CONTEXT";
+  }>["stage"], policyKey: string, cause: string): PolicyEvaluationError;
+  static invalidPolicyKey(rawPolicyKey: string, cause: string): PolicyEvaluationError;
+  static policyNotFound(policyKey: string, cause: string): PolicyEvaluationError;
+  static policyDefinitionNotFound(policyKey: string, asOf: Date, contextVersion: number, cause: string): PolicyEvaluationError;
+  static policyVariantNotFound(params: {
+    readonly policyKey: string;
+    readonly policyKind: PolicyKind;
+    readonly payloadSchemaVersion: number;
+    readonly gateEngineVersion?: number;
+    readonly computeEngineVersion?: number;
+    readonly cause: string;
+  }): PolicyEvaluationError;
+  static engineFailure(policyKey: string, engine: PolicyKind, engineVersion: number, cause: string): PolicyEvaluationError;
+}
+//#endregion
+//#region src/core/policies/service/policy-service.d.ts
+interface EvaluateInput {
+  readonly decisionId: PolicyDecisionId;
+  readonly policyKey: string;
+  readonly scopeChain: readonly PolicyScope[];
+  readonly contextVersion: number;
+  readonly seed: ContextSeed;
+}
+interface PolicyServiceOptions {
+  readonly asOf?: DeriveAsOfOptions;
+  readonly reporter?: PolicyReporter;
+}
+interface PolicyServiceParams {
+  readonly catalog: PolicyCatalog;
+  readonly contextBuilder: PolicyContextBuilder;
+  readonly defRepo: PolicyDefinitionRepository;
+  readonly resolver: PolicyResolver;
+  readonly gateEngines: GateEngineRegistry;
+  readonly computeRegistry: ComputeRegistry;
+  readonly options?: PolicyServiceOptions;
+}
+/** Union of all possible policy decision Outcomes. */
+type PolicyDecision = GateOutcome | ComputeOutcome;
+interface PolicyEvaluationResult {
+  readonly decisionId: PolicyDecisionId;
+  readonly ref: {
+    readonly definitionId: PolicyDefinitionId;
+    readonly policyKey: string;
+    readonly policyVersion: string;
+    readonly payloadHash: string;
+    readonly gateEngineVersion?: number;
+    readonly computeEngineVersion?: number;
+  };
+  readonly kind: "GATE" | "COMPUTE";
+  readonly asOf: Date;
+  readonly evaluatedAt: Date;
+  readonly contextVersion: number;
+  /** Business decision expressed as an Outcome — not a technical Result. */
+  readonly decision: PolicyDecision;
+}
+declare class PolicyService {
+  #private;
+  private readonly catalog;
+  private readonly contextBuilder;
+  private readonly defRepo;
+  private readonly resolver;
+  private readonly gateEngines;
+  private readonly computeRegistry;
+  private readonly options;
+  constructor(params: PolicyServiceParams);
+  private resolveEvaluationNow;
+  evaluate(input: EvaluateInput): Promise<Result<PolicyEvaluationResult, PolicyEvaluationError>>;
+}
+//#endregion
+export { FindCandidatesParams as A, PolicyKey as B, ContextSeed as C, InMemoryPolicyDefinitionRepository as D, PolicyPackage as E, PolicyScope as F, PolicyHashing as G, PolicyKind as H, PolicyScopeMatcher as I, coreConfig as K, ScopeChain as L, PolicyDefinition as M, PolicyDefinitionProps as N, BasePolicyDefinitionProps as O, PolicyDefinitionStatus as P, PolicyCatalog as R, ContextValueResolver as S, PolicyCatalogFactory as T, PolicyOwner as U, AsOfSource as V, PolicyScopeLevel as W, ContextResolverRegistry as _, PolicyServiceOptions as a, ContextResolverResilienceOptions as b, PolicyEvaluationErrors as c, PolicyAsOfResolver as d, PolicyContextPath as f, PolicyContextBuilderOptions as g, PolicyContextBuilder as h, PolicyService as i, GatePolicyDefinitionProps as j, ComputePolicyDefinitionProps as k, PolicyResolver as l, registerNamespacedContextResolvers as m, PolicyDecision as n, PolicyServiceParams as o, contextResolverRegistry as p, PolicyEvaluationResult as r, PolicyEvaluationError as s, EvaluateInput as t, DeriveAsOfOptions as u, registerNamespacedContextResolversIn as v, ContextSeedValidator as w, ContextResolverRetryOptions as x, ContextResolverCircuitBreakerOptions as y, PolicyCatalogEntryProps as z };
+//# sourceMappingURL=policy-service.d.ts.map