@cullet/erp-core 1.0.0

package/dist/gate-v1-payload.schema.js

@@ -0,0 +1,677 @@
+import { z } from "zod";
+//#region src/core/exceptions/domain-exception.ts
+var DomainException = class extends Error {
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, new.target.prototype);
+		this.name = new.target.name;
+	}
+};
+//#endregion
+//#region src/core/exceptions/invariant-violation-exception.ts
+var InvariantViolationException = class extends DomainException {
+	constructor(message) {
+		super(message);
+	}
+};
+//#endregion
+//#region src/core/shared/temporal-guards.ts
+function isValidDate(value) {
+	return value instanceof Date && !Number.isNaN(value.getTime());
+}
+function cloneDate(date) {
+	return new Date(date.getTime());
+}
+function assertValidDate(fieldName, value) {
+	if (!isValidDate(value)) throw new InvariantViolationException(`${fieldName} must be a valid Date instance`);
+}
+//#endregion
+//#region src/core/config/silent-policy-reporter.ts
+var SilentPolicyReporter = class {
+	report(_event) {}
+};
+//#endregion
+//#region src/core/config/core-config.ts
+function reportSafely(policyReporter, event) {
+	try {
+		policyReporter.report(event);
+	} catch {}
+}
+/**
+* Centraliza a configuracao pura do core sem depender de implementacoes
+* concretas de logging, tracing ou report.
+*/
+var CoreConfig = class {
+	#initialReporter;
+	#currentReporter;
+	constructor(options = {}) {
+		const reporter = options.observability?.reporter ?? new SilentPolicyReporter();
+		this.#initialReporter = reporter;
+		this.#currentReporter = reporter;
+	}
+	configure(options) {
+		const reporter = options.observability?.reporter;
+		if (reporter) this.#currentReporter = reporter;
+		return this;
+	}
+	reset() {
+		this.#currentReporter = this.#initialReporter;
+		return this;
+	}
+	getPolicyReporter() {
+		return this.#currentReporter;
+	}
+	getConditionEvaluationOptions(engineVersion) {
+		return {
+			reporter: this.#bridgeToConditionReporter(this.#currentReporter),
+			engineVersion
+		};
+	}
+	#bridgeToConditionReporter(policyReporter) {
+		return {
+			warn(report) {
+				reportSafely(policyReporter, {
+					kind: "condition-eval",
+					...report
+				});
+			},
+			error(report) {
+				reportSafely(policyReporter, {
+					kind: "condition-eval",
+					...report
+				});
+			}
+		};
+	}
+};
+//#endregion
+//#region src/core/config/core-config.instance.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 } })`.
+*/
+const coreConfig = new CoreConfig({ observability: { reporter: new SilentPolicyReporter() } });
+//#endregion
+//#region src/core/result/result.ts
+/**
+* Represents the outcome of an operation that may succeed or fail.
+* Useful for avoiding excessive exceptions and making error flows explicit.
+*/
+var Result = class Result {
+	constructor() {}
+	/**
+	* Creates a success result containing a value.
+	*/
+	static ok(value) {
+		return new Ok(value);
+	}
+	/**
+	* Creates an error result containing an error object.
+	*/
+	static err(error) {
+		return new Err(error);
+	}
+	/**
+	* Returns the value when this is success, or null when this is an error.
+	*/
+	getOrNull() {
+		return this.match({
+			ok: (value) => value,
+			err: () => null
+		});
+	}
+	/**
+	* Returns the error when this is a failure, or null when this is a success.
+	*/
+	errorOrNull() {
+		return this.match({
+			ok: () => null,
+			err: (error) => error
+		});
+	}
+	/**
+	* Returns the value when this is a success, or throws the error when this is a failure.
+	*/
+	getOrThrow() {
+		return this.match({
+			ok: (value) => value,
+			err: (error) => {
+				throw error instanceof Error ? error : new Error(String(error));
+			}
+		});
+	}
+	/**
+	* Transforms the success value using the provided function. Keeps the error when this is a failure.
+	*/
+	map(transform) {
+		return this.match({
+			ok: (value) => Result.ok(transform(value)),
+			err: (error) => Result.err(error)
+		});
+	}
+	/**
+	* Transforms the error using the provided function. Keeps the value when this is a success.
+	*/
+	mapError(transform) {
+		return this.match({
+			ok: (value) => Result.ok(value),
+			err: (error) => Result.err(transform(error))
+		});
+	}
+	/**
+	* Chains another operation that returns a Result when this result is a success.
+	*/
+	flatMap(transform) {
+		return this.match({
+			ok: (value) => transform(value),
+			err: (error) => Result.err(error)
+		});
+	}
+};
+/**
+* Success variant of Result.
+*/
+var Ok = class extends Result {
+	constructor(value) {
+		super();
+		this.value = value;
+		Object.freeze(this);
+	}
+	isOk() {
+		return true;
+	}
+	isErr() {
+		return false;
+	}
+	match(handlers) {
+		return handlers.ok(this.value);
+	}
+};
+/**
+* Error variant of Result.
+*/
+var Err = class extends Result {
+	constructor(error) {
+		super();
+		this.error = error;
+		Object.freeze(this);
+	}
+	isOk() {
+		return false;
+	}
+	isErr() {
+		return true;
+	}
+	match(handlers) {
+		return handlers.err(this.error);
+	}
+};
+//#endregion
+//#region src/core/policies/utils/date.ts
+var PolicyDateUtils = class {
+	static isValid(value) {
+		return isValidDate(value);
+	}
+};
+//#endregion
+//#region src/core/policies/context/path.ts
+/**
+* Utilities for reading/writing values at dot-separated paths
+* in plain objects, e.g. "installment.dueDate".
+*/
+var PolicyContextPath = class PolicyContextPath {
+	static {
+		this.FORBIDDEN_SEGMENTS = new Set([
+			"__proto__",
+			"prototype",
+			"constructor"
+		]);
+	}
+	static resolve(obj, path) {
+		const segmentsResult = PolicyContextPath.parseSegments(path);
+		if (segmentsResult.isErr()) return Result.err(segmentsResult.errorOrNull());
+		const segments = segmentsResult.getOrNull();
+		let current = obj;
+		for (const segment of segments) {
+			if (current === null || current === void 0 || typeof current !== "object") return Result.ok({
+				found: false,
+				value: void 0
+			});
+			const record = current;
+			if (!Object.prototype.hasOwnProperty.call(record, segment)) return Result.ok({
+				found: false,
+				value: void 0
+			});
+			current = record[segment];
+		}
+		return Result.ok({
+			found: true,
+			value: current
+		});
+	}
+	static parseSegments(path) {
+		if (path.trim().length === 0) return Result.err("Path cannot be empty");
+		const segments = path.split(".");
+		if (segments.some((segment) => segment.length === 0)) return Result.err(`Path "${path}" contains an empty segment`);
+		const forbiddenSegment = segments.find((segment) => PolicyContextPath.FORBIDDEN_SEGMENTS.has(segment));
+		if (forbiddenSegment !== void 0) return Result.err(`Path "${path}" contains forbidden segment "${forbiddenSegment}"`);
+		return Result.ok(segments);
+	}
+	static isPlainRecord(value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+		const prototype = Object.getPrototypeOf(value);
+		return prototype === Object.prototype || prototype === null;
+	}
+	static getOrAbsent(obj, path) {
+		const resolvedPath = PolicyContextPath.resolve(obj, path);
+		if (resolvedPath.isErr()) return Result.err("absent");
+		const { found, value } = resolvedPath.getOrNull();
+		if (!found) return Result.err("absent");
+		return Result.ok(value);
+	}
+	static has(obj, path) {
+		const resolvedPath = PolicyContextPath.resolve(obj, path);
+		if (resolvedPath.isErr()) return false;
+		return resolvedPath.getOrNull().found;
+	}
+	static set(obj, path, value) {
+		const segmentsResult = PolicyContextPath.parseSegments(path);
+		if (segmentsResult.isErr()) return Result.err(segmentsResult.errorOrNull());
+		const segments = segmentsResult.getOrNull();
+		let current = obj;
+		for (let i = 0; i < segments.length - 1; i++) {
+			const seg = segments[i];
+			const next = current[seg];
+			if (next === void 0) {
+				const container = Object.create(null);
+				current[seg] = container;
+				current = container;
+				continue;
+			}
+			if (!PolicyContextPath.isPlainRecord(next)) return Result.err(`Cannot create nested path "${path}" because "${segments.slice(0, i + 1).join(".")}" already contains a non-plain object`);
+			current = next;
+		}
+		current[segments[segments.length - 1]] = value;
+		return Result.ok(void 0);
+	}
+};
+//#endregion
+//#region src/core/policies/engines/v1/condition-schema.ts
+const conditionOpSchema = z.enum([
+	"eq",
+	"neq",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"in",
+	"notIn",
+	"isNull",
+	"isNotNull"
+]);
+const conditionLeafNodeSchema = z.object({
+	field: z.string().min(1),
+	op: conditionOpSchema,
+	value: z.unknown(),
+	allowNull: z.literal(true).optional()
+}).strict();
+const conditionNodeSchema = z.lazy(() => z.union([
+	conditionLeafNodeSchema,
+	z.object({ and: z.array(conditionNodeSchema).min(1) }).strict(),
+	z.object({ or: z.array(conditionNodeSchema).min(1) }).strict(),
+	z.object({ not: conditionNodeSchema }).strict()
+]));
+//#endregion
+//#region src/core/policies/engines/v1/condition-evaluator.ts
+const CONDITION_EVAL_THROWN_TAG = "CONDITION_EVAL_THREW";
+const NULLISH_NUMERIC_OPERAND_NOT_ALLOWED_TAG = "NULLISH_NUMERIC_OPERAND_NOT_ALLOWED";
+const NULLISH_DATE_OPERAND_NOT_ALLOWED_TAG = "NULLISH_DATE_OPERAND_NOT_ALLOWED";
+const INVALID_DATE_OPERAND_TAG = "INVALID_DATE_OPERAND";
+const EMPTY_OR_CONDITION_TAG = "EMPTY_OR_CONDITION";
+const ISO_8601_UTC_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+var ConditionEvaluatorV1 = class ConditionEvaluatorV1 {
+	constructor(context, options) {
+		this.context = context;
+		this.options = options;
+	}
+	static isLeafNode(node) {
+		return "field" in node && "op" in node;
+	}
+	static isAndNode(node) {
+		return "and" in node;
+	}
+	static isOrNode(node) {
+		return "or" in node;
+	}
+	static isNotNode(node) {
+		return "not" in node;
+	}
+	static isRelationalOperator(op) {
+		return op === "gt" || op === "gte" || op === "lt" || op === "lte";
+	}
+	static describeError(error) {
+		if (error instanceof Error) return {
+			name: error.name,
+			message: error.message
+		};
+		return {
+			name: "NonErrorThrown",
+			message: String(error)
+		};
+	}
+	static buildNullishNumericOperandMessage(node, actual) {
+		const resolvedValue = actual === null ? "null" : "undefined";
+		return `${NULLISH_NUMERIC_OPERAND_NOT_ALLOWED_TAG}: "${node.field}" resolved to ${resolvedValue} for numeric operator "${node.op}"`;
+	}
+	static buildNullishDateOperandMessage(node, actual) {
+		const resolvedValue = actual === null ? "null" : "undefined";
+		return `${NULLISH_DATE_OPERAND_NOT_ALLOWED_TAG}: "${node.field}" resolved to ${resolvedValue} for date comparison operator "${node.op}"`;
+	}
+	static buildInvalidDateOperandMessage(node) {
+		return `${INVALID_DATE_OPERAND_TAG}: "${node.field}" with operator "${node.op}" requires Date or ISO 8601 UTC string operands`;
+	}
+	static buildEmptyOrConditionMessage() {
+		return `${EMPTY_OR_CONDITION_TAG}: OR nodes must contain at least one child condition`;
+	}
+	static parseComparableDate(value) {
+		if (value instanceof Date) {
+			if (!PolicyDateUtils.isValid(value)) return Result.err("Invalid Date instance");
+			return Result.ok(value);
+		}
+		if (typeof value !== "string" || !ISO_8601_UTC_DATE_PATTERN.test(value)) return null;
+		const parsed = new Date(value);
+		if (!PolicyDateUtils.isValid(parsed) || parsed.toISOString() !== value) return Result.err("Invalid ISO 8601 UTC date string");
+		return Result.ok(parsed);
+	}
+	static evaluateRelationalNumbers(actual, op, expected) {
+		switch (op) {
+			case "gt": return actual > expected;
+			case "gte": return actual >= expected;
+			case "lt": return actual < expected;
+			case "lte": return actual <= expected;
+		}
+	}
+	buildReport(params) {
+		return {
+			occurredAt: /* @__PURE__ */ new Date(),
+			level: params.level,
+			tag: params.tag,
+			message: params.message,
+			engineVersion: this.options.engineVersion,
+			details: params.details
+		};
+	}
+	conditionEvalErr(node, error) {
+		const cause = ConditionEvaluatorV1.describeError(error);
+		const message = `${CONDITION_EVAL_THROWN_TAG}: ${cause.name}: ${cause.message}`;
+		this.options.reporter.error(this.buildReport({
+			level: "error",
+			tag: CONDITION_EVAL_THROWN_TAG,
+			message,
+			details: {
+				node,
+				cause
+			}
+		}));
+		return Result.err(message);
+	}
+	reportDateOperandError(node, actual) {
+		const message = ConditionEvaluatorV1.buildInvalidDateOperandMessage(node);
+		this.options.reporter.error(this.buildReport({
+			level: "error",
+			tag: INVALID_DATE_OPERAND_TAG,
+			message,
+			details: {
+				field: node.field,
+				op: node.op,
+				actual,
+				expected: node.value,
+				node
+			}
+		}));
+		return Result.err(message);
+	}
+	evaluateDateRelationalNode(node, actual) {
+		if (!ConditionEvaluatorV1.isRelationalOperator(node.op)) return null;
+		const actualDateResult = ConditionEvaluatorV1.parseComparableDate(actual);
+		const expectedDateResult = ConditionEvaluatorV1.parseComparableDate(node.value);
+		if (actualDateResult === null && expectedDateResult === null) return null;
+		const allowsNull = node.allowNull === true;
+		if (actual === null) {
+			if (allowsNull) return Result.ok(false);
+			const message = ConditionEvaluatorV1.buildNullishDateOperandMessage(node, actual);
+			this.options.reporter.error(this.buildReport({
+				level: "error",
+				tag: NULLISH_DATE_OPERAND_NOT_ALLOWED_TAG,
+				message,
+				details: {
+					field: node.field,
+					op: node.op,
+					actual,
+					expected: node.value,
+					allowNull: allowsNull,
+					node
+				}
+			}));
+			return Result.err(message);
+		}
+		if (actual === void 0) {
+			const message = ConditionEvaluatorV1.buildNullishDateOperandMessage(node, actual);
+			this.options.reporter.error(this.buildReport({
+				level: "error",
+				tag: NULLISH_DATE_OPERAND_NOT_ALLOWED_TAG,
+				message,
+				details: {
+					field: node.field,
+					op: node.op,
+					actual,
+					expected: node.value,
+					allowNull: allowsNull,
+					node
+				}
+			}));
+			return Result.err(message);
+		}
+		if (actualDateResult === null || actualDateResult.isErr() || expectedDateResult === null || expectedDateResult.isErr()) return this.reportDateOperandError(node, actual);
+		return Result.ok(ConditionEvaluatorV1.evaluateRelationalNumbers(actualDateResult.getOrNull().getTime(), node.op, expectedDateResult.getOrNull().getTime()));
+	}
+	evaluateOperator(actual, op, expected) {
+		switch (op) {
+			case "eq": return actual === expected;
+			case "neq": return actual !== expected;
+			case "gt": return typeof actual === "number" && typeof expected === "number" && ConditionEvaluatorV1.evaluateRelationalNumbers(actual, op, expected);
+			case "gte": return typeof actual === "number" && typeof expected === "number" && ConditionEvaluatorV1.evaluateRelationalNumbers(actual, op, expected);
+			case "lt": return typeof actual === "number" && typeof expected === "number" && ConditionEvaluatorV1.evaluateRelationalNumbers(actual, op, expected);
+			case "lte": return typeof actual === "number" && typeof expected === "number" && ConditionEvaluatorV1.evaluateRelationalNumbers(actual, op, expected);
+			case "in": return Array.isArray(expected) && expected.includes(actual);
+			case "notIn": return Array.isArray(expected) && !expected.includes(actual);
+			case "isNull": return actual === null;
+			case "isNotNull": return actual !== null && actual !== void 0;
+		}
+	}
+	evaluateNumericRelationalNode(node, actual) {
+		const allowsNull = node.allowNull === true;
+		if (actual === void 0 || actual === null && !allowsNull) {
+			const message = ConditionEvaluatorV1.buildNullishNumericOperandMessage(node, actual);
+			this.options.reporter.error(this.buildReport({
+				level: "error",
+				tag: NULLISH_NUMERIC_OPERAND_NOT_ALLOWED_TAG,
+				message,
+				details: {
+					field: node.field,
+					op: node.op,
+					actual,
+					expected: node.value,
+					allowNull: allowsNull,
+					node
+				}
+			}));
+			return Result.err(message);
+		}
+		return Result.ok(this.evaluateOperator(actual, node.op, node.value));
+	}
+	evaluateLeafNode(node) {
+		const actualResult = PolicyContextPath.getOrAbsent(this.context, node.field);
+		if (actualResult.isErr()) {
+			this.options.reporter.warn(this.buildReport({
+				level: "warn",
+				tag: "MISSING_CONTEXT_FIELD",
+				message: `MISSING_CONTEXT_FIELD: "${node.field}" not found in context`,
+				details: {
+					field: node.field,
+					node
+				}
+			}));
+			return Result.err(`MISSING_CONTEXT_FIELD: "${node.field}" not found in context`);
+		}
+		try {
+			const actual = actualResult.getOrThrow();
+			if (ConditionEvaluatorV1.isRelationalOperator(node.op)) {
+				const dateResult = this.evaluateDateRelationalNode(node, actual);
+				if (dateResult !== null) return dateResult;
+				return this.evaluateNumericRelationalNode(node, actual);
+			}
+			return Result.ok(this.evaluateOperator(actual, node.op, node.value));
+		} catch (error) {
+			return this.conditionEvalErr(node, error);
+		}
+	}
+	buildTrace(params) {
+		return {
+			conditionPath: params.conditionPath,
+			decisiveNode: params.decisiveNode,
+			lastEvaluatedLeaf: params.lastEvaluatedLeaf,
+			lastEvaluatedLeafPath: params.lastEvaluatedLeafPath,
+			lastEvaluatedLeafResult: params.lastEvaluatedLeafResult
+		};
+	}
+	evaluateWithTraceInternal(node, path) {
+		if (ConditionEvaluatorV1.isLeafNode(node)) {
+			const leafResult = this.evaluateLeafNode(node);
+			if (leafResult.isErr()) return Result.err(leafResult.errorOrNull());
+			const matched = leafResult.getOrNull();
+			return Result.ok({
+				matched,
+				trace: this.buildTrace({
+					conditionPath: path,
+					decisiveNode: node,
+					lastEvaluatedLeaf: node,
+					lastEvaluatedLeafPath: path,
+					lastEvaluatedLeafResult: matched
+				})
+			});
+		}
+		if (ConditionEvaluatorV1.isAndNode(node)) {
+			let lastTracedChild = null;
+			for (const [index, child] of node.and.entries()) {
+				const childPath = `${path}.and[${index}]`;
+				const childResult = this.evaluateWithTraceInternal(child, childPath);
+				if (childResult.isErr()) return Result.err(childResult.errorOrNull());
+				const tracedChild = childResult.getOrNull();
+				lastTracedChild = tracedChild;
+				if (!tracedChild.matched) return Result.ok({
+					matched: false,
+					trace: this.buildTrace({
+						conditionPath: childPath,
+						decisiveNode: child,
+						lastEvaluatedLeaf: tracedChild.trace.lastEvaluatedLeaf,
+						lastEvaluatedLeafPath: tracedChild.trace.lastEvaluatedLeafPath,
+						lastEvaluatedLeafResult: tracedChild.trace.lastEvaluatedLeafResult
+					})
+				});
+			}
+			return Result.ok({
+				matched: true,
+				trace: lastTracedChild.trace
+			});
+		}
+		if (ConditionEvaluatorV1.isOrNode(node)) {
+			let lastTrace = null;
+			for (const [index, child] of node.or.entries()) {
+				const childResult = this.evaluateWithTraceInternal(child, `${path}.or[${index}]`);
+				if (childResult.isErr()) return Result.err(childResult.errorOrNull());
+				const tracedChild = childResult.getOrNull();
+				lastTrace = tracedChild.trace;
+				if (tracedChild.matched) return Result.ok({
+					matched: true,
+					trace: tracedChild.trace
+				});
+			}
+			if (lastTrace === null) return Result.err(ConditionEvaluatorV1.buildEmptyOrConditionMessage());
+			return Result.ok({
+				matched: false,
+				trace: lastTrace
+			});
+		}
+		if (ConditionEvaluatorV1.isNotNode(node)) {
+			const childPath = `${path}.not`;
+			const childResult = this.evaluateWithTraceInternal(node.not, childPath);
+			if (childResult.isErr()) return Result.err(childResult.errorOrNull());
+			const tracedChild = childResult.getOrNull();
+			return Result.ok({
+				matched: !tracedChild.matched,
+				trace: this.buildTrace({
+					conditionPath: path,
+					decisiveNode: node,
+					lastEvaluatedLeaf: tracedChild.trace.lastEvaluatedLeaf,
+					lastEvaluatedLeafPath: tracedChild.trace.lastEvaluatedLeafPath,
+					lastEvaluatedLeafResult: tracedChild.trace.lastEvaluatedLeafResult
+				})
+			});
+		}
+		return this.conditionEvalErr(node, /* @__PURE__ */ new TypeError("Invalid condition node shape"));
+	}
+	evaluate(node) {
+		try {
+			const result = this.evaluateWithTraceInternal(node, "$");
+			if (result.isErr()) return Result.err(result.errorOrNull());
+			return Result.ok(result.getOrNull().matched);
+		} catch (error) {
+			return this.conditionEvalErr(node, error);
+		}
+	}
+	evaluateWithTrace(node) {
+		try {
+			return this.evaluateWithTraceInternal(node, "$");
+		} catch (error) {
+			return this.conditionEvalErr(node, error);
+		}
+	}
+	static extractFields(node) {
+		if (ConditionEvaluatorV1.isLeafNode(node)) return [node.field];
+		if (ConditionEvaluatorV1.isAndNode(node)) return node.and.flatMap((child) => ConditionEvaluatorV1.extractFields(child));
+		if (ConditionEvaluatorV1.isOrNode(node)) return node.or.flatMap((child) => ConditionEvaluatorV1.extractFields(child));
+		if (ConditionEvaluatorV1.isNotNode(node)) return ConditionEvaluatorV1.extractFields(node.not);
+		return [];
+	}
+};
+//#endregion
+//#region src/core/policies/engines/v1/gate/gate-v1-payload.schema.ts
+var GatePayloadSchemaV1 = class GatePayloadSchemaV1 {
+	static {
+		this.schema = z.union([z.object({ condition: conditionNodeSchema }).strict(), z.object({
+			allowIf: conditionNodeSchema,
+			defaultOutcome: z.enum(["ALLOW", "DENY"])
+		}).strict()]);
+	}
+	static parse(payload) {
+		const parsed = GatePayloadSchemaV1.schema.safeParse(payload);
+		if (!parsed.success) {
+			const details = parsed.error.issues.map((issue) => {
+				const path = issue.path.join(".");
+				return path.length > 0 ? `${path}: ${issue.message}` : issue.message;
+			}).join("; ");
+			return Result.err(`Invalid gate payload: ${details}`);
+		}
+		return Result.ok(parsed.data);
+	}
+};
+const gatePayloadSchema = GatePayloadSchemaV1.schema;
+//#endregion
+export { DomainException as _, conditionNodeSchema as a, Ok as c, CoreConfig as d, SilentPolicyReporter as f, InvariantViolationException as g, isValidDate as h, conditionLeafNodeSchema as i, Result as l, cloneDate as m, gatePayloadSchema as n, PolicyContextPath as o, assertValidDate as p, ConditionEvaluatorV1 as r, Err as s, GatePayloadSchemaV1 as t, coreConfig as u };
+
+//# sourceMappingURL=gate-v1-payload.schema.js.map