@objectstack/spec 0.3.2 → 0.4.1

package/dist/data/query.zod.js

@@ -1,37 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuerySchema = exports.FieldNodeSchema = exports.WindowFunctionNodeSchema = exports.WindowSpecSchema = exports.WindowFunction = exports.JoinNodeSchema = exports.JoinType = exports.AggregationNodeSchema = exports.AggregationFunction = exports.SortNodeSchema = exports.FilterNodeSchema = exports.LogicOperator = exports.FilterOperator = void 0;
+exports.QuerySchema = exports.FieldNodeSchema = exports.WindowFunctionNodeSchema = exports.WindowSpecSchema = exports.WindowFunction = exports.JoinNodeSchema = exports.JoinStrategy = exports.JoinType = exports.AggregationNodeSchema = exports.AggregationFunction = exports.SortNodeSchema = void 0;
 const zod_1 = require("zod");
-/**
- * Filter Operator Enum
- * Standard SQL/NoSQL operators supported by the engine.
- */
-exports.FilterOperator = zod_1.z.enum([
-    '=', '!=', '<>',
-    '>', '>=', '<', '<=',
-    'startswith', 'contains', 'notcontains',
-    'between', 'in', 'notin',
-    'is_null', 'is_not_null'
-]);
-/**
- * Filter Logic Operator
- */
-exports.LogicOperator = zod_1.z.enum(['and', 'or', 'not']);
-/**
- * Recursive Filter Node
- * Represents the "Where" clause.
- *
- * Structure: [Field, Operator, Value] OR [Logic, Filter, Filter...]
- * Examples:
- * - Simple: ["amount", ">", 1000]
- * - Logic: [["status", "=", "closed"], "or", ["amount", ">", 1000]]
- */
-exports.FilterNodeSchema = zod_1.z.lazy(() => zod_1.z.union([
-    // Leaf Node: [Field, Operator, Value]
-    zod_1.z.tuple([zod_1.z.string(), exports.FilterOperator, zod_1.z.any()]),
-    // Logic Node: [Expression, "or", Expression]
-    zod_1.z.array(zod_1.z.union([zod_1.z.string(), exports.FilterNodeSchema]))
-]));
+const filter_zod_1 = require("./filter.zod");
 /**
  * Sort Node
  * Represents "Order By".
@@ -119,6 +90,7 @@ exports.AggregationNodeSchema = zod_1.z.object({
     field: zod_1.z.string().optional().describe('Field to aggregate (optional for COUNT(*))'),
     alias: zod_1.z.string().describe('Result column alias'),
     distinct: zod_1.z.boolean().optional().describe('Apply DISTINCT before aggregation'),
+    filter: filter_zod_1.FilterConditionSchema.optional().describe('Filter/Condition to apply to the aggregation (FILTER WHERE clause)'),
 });
 /**
  * Join Type Enum
@@ -157,6 +129,17 @@ exports.AggregationNodeSchema = zod_1.z.object({
  * }
  */
 exports.JoinType = zod_1.z.enum(['inner', 'left', 'right', 'full']);
+/**
+ * Join Execution Strategy
+ * Hints to the query engine on how to execute the join.
+ *
+ * Strategies:
+ * - **auto**: Engine decides best strategy (Default).
+ * - **database**: Push down join to the database (Requires same datasource).
+ * - **hash**: Load both sets into memory and hash join (Cross-datasource, memory intensive).
+ * - **loop**: Nested loop lookup (N+1 safe version). (Good for small right-side lookups).
+ */
+exports.JoinStrategy = zod_1.z.enum(['auto', 'database', 'hash', 'loop']);
 /**
  * Join Node
  * Represents table joins for combining data from multiple objects.
@@ -237,9 +220,10 @@ exports.JoinType = zod_1.z.enum(['inner', 'left', 'right', 'full']);
  */
 exports.JoinNodeSchema = zod_1.z.lazy(() => zod_1.z.object({
     type: exports.JoinType.describe('Join type'),
+    strategy: exports.JoinStrategy.optional().describe('Execution strategy hint'),
     object: zod_1.z.string().describe('Object/table to join'),
     alias: zod_1.z.string().optional().describe('Table alias'),
-    on: exports.FilterNodeSchema.describe('Join condition'),
+    on: filter_zod_1.FilterConditionSchema.describe('Join condition'),
     subquery: zod_1.z.lazy(() => exports.QuerySchema).optional().describe('Subquery instead of object'),
 }));
 /**
@@ -406,101 +390,28 @@ exports.FieldNodeSchema = zod_1.z.lazy(() => zod_1.z.union([
  * This schema represents ObjectQL - a universal query language that abstracts
  * SQL, NoSQL, and SaaS APIs into a single unified interface.
  *
- * Key Features:
- * - **Filtering**: WHERE clauses with nested logic
- * - **Aggregations**: GROUP BY with COUNT, SUM, AVG, MIN, MAX
- * - **Joins**: INNER, LEFT, RIGHT, FULL OUTER joins
- * - **Window Functions**: ROW_NUMBER, RANK, LAG, LEAD, running totals
- * - **Subqueries**: Nested queries in joins and filters
- * - **Sorting & Pagination**: ORDER BY, LIMIT, OFFSET
+ * Updates (v2):
+ * - Aligned with modern ORM standards (Prisma/TypeORM)
+ * - Added `cursor` based pagination support
+ * - Renamed `top`/`skip` to `limit`/`offset`
+ * - Unified filtering syntax with `FilterConditionSchema`
  *
  * @example
  * // Simple query: SELECT name, email FROM account WHERE status = 'active'
  * {
  *   object: 'account',
  *   fields: ['name', 'email'],
- *   filters: ['status', '=', 'active']
- * }
- *
- * @example
- * // Aggregation: SELECT region, SUM(amount) as total FROM sales GROUP BY region HAVING total > 10000
- * {
- *   object: 'sales',
- *   fields: ['region'],
- *   aggregations: [
- *     { function: 'sum', field: 'amount', alias: 'total' }
- *   ],
- *   groupBy: ['region'],
- *   having: ['total', '>', 10000]
- * }
- *
- * @example
- * // Join: SELECT o.*, c.name FROM orders o INNER JOIN customers c ON o.customer_id = c.id
- * {
- *   object: 'order',
- *   fields: ['id', 'amount'],
- *   joins: [
- *     {
- *       type: 'inner',
- *       object: 'customer',
- *       alias: 'c',
- *       on: ['order.customer_id', '=', 'c.id']
- *     }
- *   ]
- * }
- *
- * @example
- * // Window Function: Top 5 orders per customer
- * {
- *   object: 'order',
- *   fields: ['customer_id', 'amount', 'created_at'],
- *   windowFunctions: [
- *     {
- *       function: 'row_number',
- *       alias: 'customer_order_rank',
- *       over: {
- *         partitionBy: ['customer_id'],
- *         orderBy: [{ field: 'amount', order: 'desc' }]
- *       }
- *     }
- *   ]
+ *   where: { status: 'active' }
  * }
  *
  * @example
- * // Complex: Customer lifetime value with rankings
+ * // Pagination with Limit/Offset
  * {
- *   object: 'customer',
- *   fields: ['id', 'name'],
- *   joins: [
- *     {
- *       type: 'left',
- *       object: 'order',
- *       alias: 'o',
- *       on: ['customer.id', '=', 'o.customer_id']
- *     }
- *   ],
- *   aggregations: [
- *     { function: 'count', field: 'o.id', alias: 'order_count' },
- *     { function: 'sum', field: 'o.amount', alias: 'lifetime_value' }
- *   ],
- *   groupBy: ['customer.id', 'customer.name'],
- *   having: ['order_count', '>', 0],
- *   sort: [{ field: 'lifetime_value', order: 'desc' }],
- *   top: 100
- * }
- *
- * @example
- * // Salesforce SOQL: SELECT Name, (SELECT LastName FROM Contacts) FROM Account
- * {
- *   object: 'account',
- *   fields: ['name'],
- *   joins: [
- *     {
- *       type: 'left',
- *       object: 'contact',
- *       on: ['account.id', '=', 'contact.account_id']
- *     }
- *   ]
+ *   object: 'post',
+ *   where: { published: true },
+ *   orderBy: [{ field: 'created_at', order: 'desc' }],
+ *   limit: 20,
+ *   offset: 40
  * }
  */
 exports.QuerySchema = zod_1.z.object({
@@ -508,23 +419,24 @@ exports.QuerySchema = zod_1.z.object({
     object: zod_1.z.string().describe('Object name (e.g. account)'),
     /** Select Clause */
     fields: zod_1.z.array(exports.FieldNodeSchema).optional().describe('Fields to retrieve'),
-    /** Aggregations */
-    aggregations: zod_1.z.array(exports.AggregationNodeSchema).optional().describe('Aggregation functions (GROUP BY)'),
-    /** Window Functions */
-    windowFunctions: zod_1.z.array(exports.WindowFunctionNodeSchema).optional().describe('Window functions with OVER clause'),
-    /** Where Clause */
-    filters: exports.FilterNodeSchema.optional().describe('Filtering criteria'),
+    /** Where Clause (Filtering) */
+    where: filter_zod_1.FilterConditionSchema.optional().describe('Filtering criteria (WHERE)'),
+    /** Order By Clause (Sorting) */
+    orderBy: zod_1.z.array(exports.SortNodeSchema).optional().describe('Sorting instructions (ORDER BY)'),
+    /** Pagination */
+    limit: zod_1.z.number().optional().describe('Max records to return (LIMIT)'),
+    offset: zod_1.z.number().optional().describe('Records to skip (OFFSET)'),
+    cursor: zod_1.z.record(zod_1.z.any()).optional().describe('Cursor for keyset pagination'),
     /** Joins */
-    joins: zod_1.z.array(exports.JoinNodeSchema).optional().describe('Table joins'),
+    joins: zod_1.z.array(exports.JoinNodeSchema).optional().describe('Explicit Table Joins'),
+    /** Aggregations */
+    aggregations: zod_1.z.array(exports.AggregationNodeSchema).optional().describe('Aggregation functions'),
     /** Group By Clause */
     groupBy: zod_1.z.array(zod_1.z.string()).optional().describe('GROUP BY fields'),
     /** Having Clause */
-    having: exports.FilterNodeSchema.optional().describe('HAVING clause for aggregation filtering'),
-    /** Order By Clause */
-    sort: zod_1.z.array(exports.SortNodeSchema).optional().describe('Sorting instructions'),
-    /** Pagination */
-    top: zod_1.z.number().optional().describe('Limit results'),
-    skip: zod_1.z.number().optional().describe('Offset results'),
+    having: filter_zod_1.FilterConditionSchema.optional().describe('HAVING clause for aggregation filtering'),
+    /** Window Functions */
+    windowFunctions: zod_1.z.array(exports.WindowFunctionNodeSchema).optional().describe('Window functions with OVER clause'),
     /** Subquery flag */
     distinct: zod_1.z.boolean().optional().describe('SELECT DISTINCT flag'),
 });

package/dist/data/validation.zod.d.ts

@@ -5,7 +5,11 @@ import { z } from 'zod';
  */
 export declare const ScriptValidationSchema: z.ZodObject<{
     name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
     active: z.ZodDefault<z.ZodBoolean>;
+    events: z.ZodDefault<z.ZodArray<z.ZodEnum<["insert", "update", "delete"]>, "many">>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
     message: z.ZodString;
 } & {
@@ -16,14 +20,22 @@ export declare const ScriptValidationSchema: z.ZodObject<{
     type: "script";
     name: string;
     active: boolean;
+    events: ("insert" | "update" | "delete")[];
     severity: "error" | "warning" | "info";
     condition: string;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
 }, {
     message: string;
     type: "script";
     name: string;
     condition: string;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
     active?: boolean | undefined;
+    events?: ("insert" | "update" | "delete")[] | undefined;
     severity?: "error" | "warning" | "info" | undefined;
 }>;
 /**
@@ -32,7 +44,11 @@ export declare const ScriptValidationSchema: z.ZodObject<{
  */
 export declare const UniquenessValidationSchema: z.ZodObject<{
     name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
     active: z.ZodDefault<z.ZodBoolean>;
+    events: z.ZodDefault<z.ZodArray<z.ZodEnum<["insert", "update", "delete"]>, "many">>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
     message: z.ZodString;
 } & {
@@ -43,18 +59,26 @@ export declare const UniquenessValidationSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     message: string;
     type: "unique";
-    name: string;
     fields: string[];
+    name: string;
     active: boolean;
+    events: ("insert" | "update" | "delete")[];
     severity: "error" | "warning" | "info";
     caseSensitive: boolean;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
     scope?: string | undefined;
 }, {
     message: string;
     type: "unique";
-    name: string;
     fields: string[];
+    name: string;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
     active?: boolean | undefined;
+    events?: ("insert" | "update" | "delete")[] | undefined;
     severity?: "error" | "warning" | "info" | undefined;
     scope?: string | undefined;
     caseSensitive?: boolean | undefined;
@@ -65,7 +89,11 @@ export declare const UniquenessValidationSchema: z.ZodObject<{
  */
 export declare const StateMachineValidationSchema: z.ZodObject<{
     name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
     active: z.ZodDefault<z.ZodBoolean>;
+    events: z.ZodDefault<z.ZodArray<z.ZodEnum<["insert", "update", "delete"]>, "many">>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
     message: z.ZodString;
 } & {
@@ -75,18 +103,26 @@ export declare const StateMachineValidationSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     message: string;
     type: "state_machine";
-    name: string;
     field: string;
+    name: string;
     active: boolean;
+    events: ("insert" | "update" | "delete")[];
     severity: "error" | "warning" | "info";
     transitions: Record<string, string[]>;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
 }, {
     message: string;
     type: "state_machine";
-    name: string;
     field: string;
+    name: string;
     transitions: Record<string, string[]>;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
     active?: boolean | undefined;
+    events?: ("insert" | "update" | "delete")[] | undefined;
     severity?: "error" | "warning" | "info" | undefined;
 }>;
 /**
@@ -95,7 +131,11 @@ export declare const StateMachineValidationSchema: z.ZodObject<{
  */
 export declare const FormatValidationSchema: z.ZodObject<{
     name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
     active: z.ZodDefault<z.ZodBoolean>;
+    events: z.ZodDefault<z.ZodArray<z.ZodEnum<["insert", "update", "delete"]>, "many">>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
     message: z.ZodString;
 } & {
@@ -106,19 +146,27 @@ export declare const FormatValidationSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     message: string;
     type: "format";
-    name: string;
     field: string;
+    name: string;
     active: boolean;
+    events: ("insert" | "update" | "delete")[];
     severity: "error" | "warning" | "info";
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
     format?: "email" | "url" | "phone" | "json" | undefined;
     regex?: string | undefined;
 }, {
     message: string;
     type: "format";
-    name: string;
     field: string;
+    name: string;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
     format?: "email" | "url" | "phone" | "json" | undefined;
     active?: boolean | undefined;
+    events?: ("insert" | "update" | "delete")[] | undefined;
     severity?: "error" | "warning" | "info" | undefined;
     regex?: string | undefined;
 }>;
@@ -187,7 +235,11 @@ export declare const FormatValidationSchema: z.ZodObject<{
  */
 export declare const CrossFieldValidationSchema: z.ZodObject<{
     name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
     active: z.ZodDefault<z.ZodBoolean>;
+    events: z.ZodDefault<z.ZodArray<z.ZodEnum<["insert", "update", "delete"]>, "many">>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
     message: z.ZodString;
 } & {
@@ -197,22 +249,77 @@ export declare const CrossFieldValidationSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     message: string;
     type: "cross_field";
-    name: string;
     fields: string[];
+    name: string;
     active: boolean;
+    events: ("insert" | "update" | "delete")[];
     severity: "error" | "warning" | "info";
     condition: string;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
 }, {
     message: string;
     type: "cross_field";
-    name: string;
     fields: string[];
+    name: string;
     condition: string;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
+    active?: boolean | undefined;
+    events?: ("insert" | "update" | "delete")[] | undefined;
+    severity?: "error" | "warning" | "info" | undefined;
+}>;
+/**
+ * 6. JSON Structure Validation
+ * Validates JSON fields against a JSON Schema.
+ *
+ * ## Use Cases
+ * - Validating configuration objects stored in JSON fields
+ * - Enforcing API payload structures
+ * - Complex nested data validation
+ */
+export declare const JSONValidationSchema: z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    active: z.ZodDefault<z.ZodBoolean>;
+    events: z.ZodDefault<z.ZodArray<z.ZodEnum<["insert", "update", "delete"]>, "many">>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
+    message: z.ZodString;
+} & {
+    type: z.ZodLiteral<"json_schema">;
+    field: z.ZodString;
+    schema: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "json_schema";
+    field: string;
+    name: string;
+    active: boolean;
+    events: ("insert" | "update" | "delete")[];
+    severity: "error" | "warning" | "info";
+    schema: Record<string, any>;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
+}, {
+    message: string;
+    type: "json_schema";
+    field: string;
+    name: string;
+    schema: Record<string, any>;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
     active?: boolean | undefined;
+    events?: ("insert" | "update" | "delete")[] | undefined;
     severity?: "error" | "warning" | "info" | undefined;
 }>;
 /**
- * 6. Async Validation
+ * 7. Async Validation
  * Remote validation via API call or database query.
  *
  * ## Use Cases
@@ -325,23 +432,22 @@ export declare const CrossFieldValidationSchema: z.ZodObject<{
  *   }
  * }
  * ```
- *
- * ## Best Practices
- * - Always set a reasonable `timeout` (default is 5000ms)
- * - Use `debounce` for fields that are typed (300-500ms recommended)
- * - Implement proper error handling on the server side
- * - Cache validation results when appropriate
- * - Consider rate limiting for external API calls
  */
 export declare const AsyncValidationSchema: z.ZodObject<{
     name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
     active: z.ZodDefault<z.ZodBoolean>;
+    events: z.ZodDefault<z.ZodArray<z.ZodEnum<["insert", "update", "delete"]>, "many">>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
     message: z.ZodString;
 } & {
     type: z.ZodLiteral<"async">;
     field: z.ZodString;
     validatorUrl: z.ZodOptional<z.ZodString>;
+    method: z.ZodDefault<z.ZodEnum<["GET", "POST"]>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     validatorFunction: z.ZodOptional<z.ZodString>;
     timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     debounce: z.ZodOptional<z.ZodNumber>;
@@ -349,63 +455,84 @@ export declare const AsyncValidationSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     message: string;
     type: "async";
-    name: string;
     field: string;
+    name: string;
     active: boolean;
+    events: ("insert" | "update" | "delete")[];
     severity: "error" | "warning" | "info";
+    method: "GET" | "POST";
     timeout: number;
     params?: Record<string, any> | undefined;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
     validatorUrl?: string | undefined;
+    headers?: Record<string, string> | undefined;
     validatorFunction?: string | undefined;
     debounce?: number | undefined;
 }, {
     message: string;
     type: "async";
-    name: string;
     field: string;
+    name: string;
     params?: Record<string, any> | undefined;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
     active?: boolean | undefined;
+    events?: ("insert" | "update" | "delete")[] | undefined;
     severity?: "error" | "warning" | "info" | undefined;
     validatorUrl?: string | undefined;
+    method?: "GET" | "POST" | undefined;
+    headers?: Record<string, string> | undefined;
     validatorFunction?: string | undefined;
     timeout?: number | undefined;
     debounce?: number | undefined;
 }>;
 /**
- * 7. Custom Validator Function
+ * 8. Custom Validator Function
  * User-defined validation logic with code reference.
  */
 export declare const CustomValidatorSchema: z.ZodObject<{
     name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
     active: z.ZodDefault<z.ZodBoolean>;
+    events: z.ZodDefault<z.ZodArray<z.ZodEnum<["insert", "update", "delete"]>, "many">>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
     message: z.ZodString;
 } & {
     type: z.ZodLiteral<"custom">;
-    field: z.ZodOptional<z.ZodString>;
-    validatorFunction: z.ZodString;
+    handler: z.ZodString;
     params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, "strip", z.ZodTypeAny, {
     message: string;
     type: "custom";
     name: string;
     active: boolean;
+    events: ("insert" | "update" | "delete")[];
     severity: "error" | "warning" | "info";
-    validatorFunction: string;
+    handler: string;
     params?: Record<string, any> | undefined;
-    field?: string | undefined;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
 }, {
     message: string;
     type: "custom";
     name: string;
-    validatorFunction: string;
+    handler: string;
     params?: Record<string, any> | undefined;
-    field?: string | undefined;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
     active?: boolean | undefined;
+    events?: ("insert" | "update" | "delete")[] | undefined;
     severity?: "error" | "warning" | "info" | undefined;
 }>;
 /**
- * Master Validation Rule Schema (forward declared for circular reference)
+ * 9. Master Validation Rule Schema
  */
 export declare const ValidationRuleSchema: z.ZodType<any>;
 /**
@@ -586,7 +713,11 @@ export declare const ValidationRuleSchema: z.ZodType<any>;
  */
 export declare const ConditionalValidationSchema: z.ZodObject<{
     name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
     active: z.ZodDefault<z.ZodBoolean>;
+    events: z.ZodDefault<z.ZodArray<z.ZodEnum<["insert", "update", "delete"]>, "many">>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
     message: z.ZodString;
 } & {
@@ -599,8 +730,12 @@ export declare const ConditionalValidationSchema: z.ZodObject<{
     type: "conditional";
     name: string;
     active: boolean;
+    events: ("insert" | "update" | "delete")[];
     severity: "error" | "warning" | "info";
     when: string;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
     then?: any;
     otherwise?: any;
 }, {
@@ -608,7 +743,11 @@ export declare const ConditionalValidationSchema: z.ZodObject<{
     type: "conditional";
     name: string;
     when: string;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
     active?: boolean | undefined;
+    events?: ("insert" | "update" | "delete")[] | undefined;
     severity?: "error" | "warning" | "info" | undefined;
     then?: any;
     otherwise?: any;
@@ -619,6 +758,7 @@ export type UniquenessValidation = z.infer<typeof UniquenessValidationSchema>;
 export type StateMachineValidation = z.infer<typeof StateMachineValidationSchema>;
 export type FormatValidation = z.infer<typeof FormatValidationSchema>;
 export type CrossFieldValidation = z.infer<typeof CrossFieldValidationSchema>;
+export type JSONValidation = z.infer<typeof JSONValidationSchema>;
 export type AsyncValidation = z.infer<typeof AsyncValidationSchema>;
 export type CustomValidation = z.infer<typeof CustomValidatorSchema>;
 export type ConditionalValidation = z.infer<typeof ConditionalValidationSchema>;

package/dist/data/validation.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.zod.d.ts","sourceRoot":"","sources":["../../src/data/validation.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2DxB;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKrC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;EAIvC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKjC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;EAIrC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyHG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQhC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAW/C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+KG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACrE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}
+{"version":3,"file":"validation.zod.d.ts","sourceRoot":"","sources":["../../src/data/validation.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2ExB;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKrC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIvC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKjC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIrC,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI/B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkHG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUhC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAY/C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+KG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACrE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}