@cullet/erp-core 1.2.0 → 1.3.0

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

@@ -0,0 +1,638 @@
+const require_temporal_guards = require("./temporal-guards.cjs");
+const require_result = require("./result.cjs");
+let zod = require("zod");
+//#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/policies/utils/date.ts
+var PolicyDateUtils = class {
+	static isValid(value) {
+		return require_temporal_guards.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 require_result.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 require_result.Result.ok({
+				found: false,
+				value: void 0
+			});
+			const record = current;
+			if (!Object.prototype.hasOwnProperty.call(record, segment)) return require_result.Result.ok({
+				found: false,
+				value: void 0
+			});
+			current = record[segment];
+		}
+		return require_result.Result.ok({
+			found: true,
+			value: current
+		});
+	}
+	static parseSegments(path) {
+		if (path.trim().length === 0) return require_result.Result.err("Path cannot be empty");
+		const segments = path.split(".");
+		if (segments.some((segment) => segment.length === 0)) return require_result.Result.err(`Path "${path}" contains an empty segment`);
+		const forbiddenSegment = segments.find((segment) => PolicyContextPath.FORBIDDEN_SEGMENTS.has(segment));
+		if (forbiddenSegment !== void 0) return require_result.Result.err(`Path "${path}" contains forbidden segment "${forbiddenSegment}"`);
+		return require_result.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 require_result.Result.err("absent");
+		const { found, value } = resolvedPath.getOrNull();
+		if (!found) return require_result.Result.err("absent");
+		return require_result.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 require_result.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 require_result.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 require_result.Result.ok(void 0);
+	}
+};
+//#endregion
+//#region src/core/policies/engines/v1/condition-schema.ts
+const conditionOpSchema = zod.z.enum([
+	"eq",
+	"neq",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"in",
+	"notIn",
+	"isNull",
+	"isNotNull"
+]);
+const conditionLeafNodeSchema = zod.z.object({
+	field: zod.z.string().min(1),
+	op: conditionOpSchema,
+	value: zod.z.unknown(),
+	allowNull: zod.z.literal(true).optional()
+}).strict();
+const conditionNodeSchema = zod.z.lazy(() => zod.z.union([
+	conditionLeafNodeSchema,
+	zod.z.object({ and: zod.z.array(conditionNodeSchema).min(1) }).strict(),
+	zod.z.object({ or: zod.z.array(conditionNodeSchema).min(1) }).strict(),
+	zod.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 INVALID_NUMERIC_OPERAND_TAG = "INVALID_NUMERIC_OPERAND";
+const INVALID_SET_OPERAND_TAG = "INVALID_SET_OPERAND";
+const EMPTY_OR_CONDITION_TAG = "EMPTY_OR_CONDITION";
+const EMPTY_AND_CONDITION_TAG = "EMPTY_AND_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 buildInvalidNumericOperandMessage(node) {
+		return `${INVALID_NUMERIC_OPERAND_TAG}: "${node.field}" with operator "${node.op}" requires numeric operands`;
+	}
+	static buildInvalidSetOperandMessage(node) {
+		return `${INVALID_SET_OPERAND_TAG}: "${node.field}" with operator "${node.op}" requires an array operand`;
+	}
+	static buildEmptyOrConditionMessage() {
+		return `${EMPTY_OR_CONDITION_TAG}: OR nodes must contain at least one child condition`;
+	}
+	static buildEmptyAndConditionMessage() {
+		return `${EMPTY_AND_CONDITION_TAG}: AND nodes must contain at least one child condition`;
+	}
+	static parseComparableDate(value) {
+		if (value instanceof Date) {
+			if (!PolicyDateUtils.isValid(value)) return require_result.Result.err("Invalid Date instance");
+			return require_result.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 require_result.Result.err("Invalid ISO 8601 UTC date string");
+		return require_result.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 require_result.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 require_result.Result.err(message);
+	}
+	reportInvalidNumericOperand(node, actual) {
+		const message = ConditionEvaluatorV1.buildInvalidNumericOperandMessage(node);
+		this.options.reporter.error(this.buildReport({
+			level: "error",
+			tag: INVALID_NUMERIC_OPERAND_TAG,
+			message,
+			details: {
+				field: node.field,
+				op: node.op,
+				actual,
+				expected: node.value,
+				node
+			}
+		}));
+		return require_result.Result.err(message);
+	}
+	reportInvalidSetOperand(node, actual) {
+		const message = ConditionEvaluatorV1.buildInvalidSetOperandMessage(node);
+		this.options.reporter.error(this.buildReport({
+			level: "error",
+			tag: INVALID_SET_OPERAND_TAG,
+			message,
+			details: {
+				field: node.field,
+				op: node.op,
+				actual,
+				expected: node.value,
+				node
+			}
+		}));
+		return require_result.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 require_result.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 require_result.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 require_result.Result.err(message);
+		}
+		if (actualDateResult === null || actualDateResult.isErr() || expectedDateResult === null || expectedDateResult.isErr()) return this.reportDateOperandError(node, actual);
+		return require_result.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 require_result.Result.err(message);
+		}
+		if (actual === null) return require_result.Result.ok(false);
+		if (typeof actual !== "number" || typeof node.value !== "number") return this.reportInvalidNumericOperand(node, actual);
+		return require_result.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 require_result.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);
+			}
+			if ((node.op === "in" || node.op === "notIn") && !Array.isArray(node.value)) return this.reportInvalidSetOperand(node, actual);
+			return require_result.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 require_result.Result.err(leafResult.errorOrNull());
+			const matched = leafResult.getOrNull();
+			return require_result.Result.ok({
+				matched,
+				trace: this.buildTrace({
+					conditionPath: path,
+					decisiveNode: node,
+					lastEvaluatedLeaf: node,
+					lastEvaluatedLeafPath: path,
+					lastEvaluatedLeafResult: matched
+				})
+			});
+		}
+		if (ConditionEvaluatorV1.isAndNode(node)) {
+			if (node.and.length === 0) return require_result.Result.err(ConditionEvaluatorV1.buildEmptyAndConditionMessage());
+			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 require_result.Result.err(childResult.errorOrNull());
+				const tracedChild = childResult.getOrNull();
+				lastTracedChild = tracedChild;
+				if (!tracedChild.matched) return require_result.Result.ok({
+					matched: false,
+					trace: this.buildTrace({
+						conditionPath: childPath,
+						decisiveNode: child,
+						lastEvaluatedLeaf: tracedChild.trace.lastEvaluatedLeaf,
+						lastEvaluatedLeafPath: tracedChild.trace.lastEvaluatedLeafPath,
+						lastEvaluatedLeafResult: tracedChild.trace.lastEvaluatedLeafResult
+					})
+				});
+			}
+			return require_result.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 require_result.Result.err(childResult.errorOrNull());
+				const tracedChild = childResult.getOrNull();
+				lastTrace = tracedChild.trace;
+				if (tracedChild.matched) return require_result.Result.ok({
+					matched: true,
+					trace: tracedChild.trace
+				});
+			}
+			if (lastTrace === null) return require_result.Result.err(ConditionEvaluatorV1.buildEmptyOrConditionMessage());
+			return require_result.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 require_result.Result.err(childResult.errorOrNull());
+			const tracedChild = childResult.getOrNull();
+			return require_result.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 require_result.Result.err(result.errorOrNull());
+			return require_result.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 = zod.z.union([zod.z.object({ condition: conditionNodeSchema }).strict(), zod.z.object({
+			allowIf: conditionNodeSchema,
+			defaultOutcome: zod.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 require_result.Result.err(`Invalid gate payload: ${details}`);
+		}
+		return require_result.Result.ok(parsed.data);
+	}
+};
+const gatePayloadSchema = GatePayloadSchemaV1.schema;
+//#endregion
+Object.defineProperty(exports, "ConditionEvaluatorV1", {
+	enumerable: true,
+	get: function() {
+		return ConditionEvaluatorV1;
+	}
+});
+Object.defineProperty(exports, "CoreConfig", {
+	enumerable: true,
+	get: function() {
+		return CoreConfig;
+	}
+});
+Object.defineProperty(exports, "GatePayloadSchemaV1", {
+	enumerable: true,
+	get: function() {
+		return GatePayloadSchemaV1;
+	}
+});
+Object.defineProperty(exports, "PolicyContextPath", {
+	enumerable: true,
+	get: function() {
+		return PolicyContextPath;
+	}
+});
+Object.defineProperty(exports, "SilentPolicyReporter", {
+	enumerable: true,
+	get: function() {
+		return SilentPolicyReporter;
+	}
+});
+Object.defineProperty(exports, "conditionLeafNodeSchema", {
+	enumerable: true,
+	get: function() {
+		return conditionLeafNodeSchema;
+	}
+});
+Object.defineProperty(exports, "conditionNodeSchema", {
+	enumerable: true,
+	get: function() {
+		return conditionNodeSchema;
+	}
+});
+Object.defineProperty(exports, "coreConfig", {
+	enumerable: true,
+	get: function() {
+		return coreConfig;
+	}
+});
+Object.defineProperty(exports, "gatePayloadSchema", {
+	enumerable: true,
+	get: function() {
+		return gatePayloadSchema;
+	}
+});
+
+//# sourceMappingURL=gate-v1-payload.schema.cjs.map