@objectstack/spec 0.1.0 → 0.1.2

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

@@ -0,0 +1,438 @@
+import { z } from 'zod';
+/**
+ * Filter Operator Enum
+ * Standard SQL/NoSQL operators supported by the engine.
+ */
+export declare const FilterOperator: z.ZodEnum<["=", "!=", "<>", ">", ">=", "<", "<=", "startswith", "contains", "notcontains", "between", "in", "notin", "is_null", "is_not_null"]>;
+/**
+ * Filter Logic Operator
+ */
+export declare const LogicOperator: z.ZodEnum<["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]]
+ */
+export declare const FilterNodeSchema: z.ZodType<any>;
+/**
+ * Sort Node
+ * Represents "Order By".
+ */
+export declare const SortNodeSchema: z.ZodObject<{
+    field: z.ZodString;
+    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+}, "strip", z.ZodTypeAny, {
+    field: string;
+    order: "asc" | "desc";
+}, {
+    field: string;
+    order?: "asc" | "desc" | undefined;
+}>;
+/**
+ * Aggregation Function Enum
+ * Standard aggregation functions.
+ */
+export declare const AggregationFunction: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+/**
+ * Aggregation Node
+ * Represents aggregated field with function.
+ */
+export declare const AggregationNodeSchema: z.ZodObject<{
+    function: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+    field: z.ZodOptional<z.ZodString>;
+    alias: z.ZodString;
+    distinct: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+    alias: string;
+    field?: string | undefined;
+    distinct?: boolean | undefined;
+}, {
+    function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+    alias: string;
+    field?: string | undefined;
+    distinct?: boolean | undefined;
+}>;
+/**
+ * Join Type Enum
+ */
+export declare const JoinType: z.ZodEnum<["inner", "left", "right", "full"]>;
+/**
+ * Join Node
+ * Represents table joins.
+ */
+export declare const JoinNodeSchema: z.ZodType<any>;
+/**
+ * Window Function Enum
+ */
+export declare const WindowFunction: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+/**
+ * Window Specification
+ * Defines PARTITION BY and ORDER BY for window functions.
+ */
+export declare const WindowSpecSchema: z.ZodObject<{
+    partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+    }, "strip", z.ZodTypeAny, {
+        field: string;
+        order: "asc" | "desc";
+    }, {
+        field: string;
+        order?: "asc" | "desc" | undefined;
+    }>, "many">>;
+    frame: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+        start: z.ZodOptional<z.ZodString>;
+        end: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "rows" | "range" | undefined;
+        start?: string | undefined;
+        end?: string | undefined;
+    }, {
+        type?: "rows" | "range" | undefined;
+        start?: string | undefined;
+        end?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    partitionBy?: string[] | undefined;
+    orderBy?: {
+        field: string;
+        order: "asc" | "desc";
+    }[] | undefined;
+    frame?: {
+        type?: "rows" | "range" | undefined;
+        start?: string | undefined;
+        end?: string | undefined;
+    } | undefined;
+}, {
+    partitionBy?: string[] | undefined;
+    orderBy?: {
+        field: string;
+        order?: "asc" | "desc" | undefined;
+    }[] | undefined;
+    frame?: {
+        type?: "rows" | "range" | undefined;
+        start?: string | undefined;
+        end?: string | undefined;
+    } | undefined;
+}>;
+/**
+ * Window Function Node
+ * Represents window function with OVER clause.
+ */
+export declare const WindowFunctionNodeSchema: z.ZodObject<{
+    function: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+    field: z.ZodOptional<z.ZodString>;
+    alias: z.ZodString;
+    over: z.ZodObject<{
+        partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            order: "asc" | "desc";
+        }, {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }>, "many">>;
+        frame: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+            start: z.ZodOptional<z.ZodString>;
+            end: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        }, {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        partitionBy?: string[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        frame?: {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        } | undefined;
+    }, {
+        partitionBy?: string[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        frame?: {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+    alias: string;
+    over: {
+        partitionBy?: string[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        frame?: {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        } | undefined;
+    };
+    field?: string | undefined;
+}, {
+    function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+    alias: string;
+    over: {
+        partitionBy?: string[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        frame?: {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        } | undefined;
+    };
+    field?: string | undefined;
+}>;
+/**
+ * Field Selection Node
+ * Represents "Select" attributes, including joins.
+ */
+export declare const FieldNodeSchema: z.ZodType<any>;
+/**
+ * Query AST Schema
+ * The universal data retrieval contract defined in `ast-structure.mdx`.
+ */
+export declare const QuerySchema: z.ZodObject<{
+    /** Target Entity */
+    object: z.ZodString;
+    /** Select Clause */
+    fields: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+    /** Aggregations */
+    aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        function: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+        field: z.ZodOptional<z.ZodString>;
+        alias: z.ZodString;
+        distinct: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+        alias: string;
+        field?: string | undefined;
+        distinct?: boolean | undefined;
+    }, {
+        function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+        alias: string;
+        field?: string | undefined;
+        distinct?: boolean | undefined;
+    }>, "many">>;
+    /** Window Functions */
+    windowFunctions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        function: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+        field: z.ZodOptional<z.ZodString>;
+        alias: z.ZodString;
+        over: z.ZodObject<{
+            partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+            }, "strip", z.ZodTypeAny, {
+                field: string;
+                order: "asc" | "desc";
+            }, {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }>, "many">>;
+            frame: z.ZodOptional<z.ZodObject<{
+                type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+                start: z.ZodOptional<z.ZodString>;
+                end: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            }, {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            partitionBy?: string[] | undefined;
+            orderBy?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        }, {
+            partitionBy?: string[] | undefined;
+            orderBy?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+        alias: string;
+        over: {
+            partitionBy?: string[] | undefined;
+            orderBy?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        };
+        field?: string | undefined;
+    }, {
+        function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+        alias: string;
+        over: {
+            partitionBy?: string[] | undefined;
+            orderBy?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        };
+        field?: string | undefined;
+    }>, "many">>;
+    /** Where Clause */
+    filters: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+    /** Joins */
+    joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+    /** Group By Clause */
+    groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Having Clause */
+    having: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+    /** Order By Clause */
+    sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+    }, "strip", z.ZodTypeAny, {
+        field: string;
+        order: "asc" | "desc";
+    }, {
+        field: string;
+        order?: "asc" | "desc" | undefined;
+    }>, "many">>;
+    /** Pagination */
+    top: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+    /** Subquery flag */
+    distinct: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    sort?: {
+        field: string;
+        order: "asc" | "desc";
+    }[] | undefined;
+    fields?: any[] | undefined;
+    distinct?: boolean | undefined;
+    aggregations?: {
+        function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+        alias: string;
+        field?: string | undefined;
+        distinct?: boolean | undefined;
+    }[] | undefined;
+    windowFunctions?: {
+        function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+        alias: string;
+        over: {
+            partitionBy?: string[] | undefined;
+            orderBy?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        };
+        field?: string | undefined;
+    }[] | undefined;
+    filters?: any;
+    joins?: any[] | undefined;
+    groupBy?: string[] | undefined;
+    having?: any;
+    top?: number | undefined;
+    skip?: number | undefined;
+}, {
+    object: string;
+    sort?: {
+        field: string;
+        order?: "asc" | "desc" | undefined;
+    }[] | undefined;
+    fields?: any[] | undefined;
+    distinct?: boolean | undefined;
+    aggregations?: {
+        function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+        alias: string;
+        field?: string | undefined;
+        distinct?: boolean | undefined;
+    }[] | undefined;
+    windowFunctions?: {
+        function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+        alias: string;
+        over: {
+            partitionBy?: string[] | undefined;
+            orderBy?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        };
+        field?: string | undefined;
+    }[] | undefined;
+    filters?: any;
+    joins?: any[] | undefined;
+    groupBy?: string[] | undefined;
+    having?: any;
+    top?: number | undefined;
+    skip?: number | undefined;
+}>;
+export type QueryAST = z.infer<typeof QuerySchema>;
+export type QueryInput = z.input<typeof QuerySchema>;
+export type FilterNode = z.infer<typeof FilterNodeSchema>;
+export type SortNode = z.infer<typeof SortNodeSchema>;
+export type AggregationNode = z.infer<typeof AggregationNodeSchema>;
+export type JoinNode = z.infer<typeof JoinNodeSchema>;
+export type WindowFunctionNode = z.infer<typeof WindowFunctionNodeSchema>;
+export type WindowSpec = z.infer<typeof WindowSpecSchema>;
+//# sourceMappingURL=query.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.zod.d.ts","sourceRoot":"","sources":["../../src/data/query.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,cAAc,iJAMzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa,iCAA+B,CAAC;AAE1D;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAQ3C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;EAGzB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB,+FAG9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EAKhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,QAAQ,+CAA6C,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAQzC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,kJAIzB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ3B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKnC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAS1C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW;IACtB,oBAAoB;;IAGpB,oBAAoB;;IAGpB,mBAAmB;;;;;;;;;;;;;;;;;IAGnB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGvB,mBAAmB;;IAGnB,YAAY;;IAGZ,sBAAsB;;IAGtB,oBAAoB;;IAGpB,sBAAsB;;;;;;;;;;;IAGtB,iBAAiB;;;IAIjB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEpB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACnD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACrD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/data/query.zod.js

@@ -0,0 +1,147 @@
+"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;
+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]))
+]));
+/**
+ * Sort Node
+ * Represents "Order By".
+ */
+exports.SortNodeSchema = zod_1.z.object({
+    field: zod_1.z.string(),
+    order: zod_1.z.enum(['asc', 'desc']).default('asc')
+});
+/**
+ * Aggregation Function Enum
+ * Standard aggregation functions.
+ */
+exports.AggregationFunction = zod_1.z.enum([
+    'count', 'sum', 'avg', 'min', 'max',
+    'count_distinct', 'array_agg', 'string_agg'
+]);
+/**
+ * Aggregation Node
+ * Represents aggregated field with function.
+ */
+exports.AggregationNodeSchema = zod_1.z.object({
+    function: exports.AggregationFunction.describe('Aggregation function'),
+    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'),
+});
+/**
+ * Join Type Enum
+ */
+exports.JoinType = zod_1.z.enum(['inner', 'left', 'right', 'full']);
+/**
+ * Join Node
+ * Represents table joins.
+ */
+exports.JoinNodeSchema = zod_1.z.lazy(() => zod_1.z.object({
+    type: exports.JoinType.describe('Join type'),
+    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'),
+    subquery: zod_1.z.lazy(() => exports.QuerySchema).optional().describe('Subquery instead of object'),
+}));
+/**
+ * Window Function Enum
+ */
+exports.WindowFunction = zod_1.z.enum([
+    'row_number', 'rank', 'dense_rank', 'percent_rank',
+    'lag', 'lead', 'first_value', 'last_value',
+    'sum', 'avg', 'count', 'min', 'max'
+]);
+/**
+ * Window Specification
+ * Defines PARTITION BY and ORDER BY for window functions.
+ */
+exports.WindowSpecSchema = zod_1.z.object({
+    partitionBy: zod_1.z.array(zod_1.z.string()).optional().describe('PARTITION BY fields'),
+    orderBy: zod_1.z.array(exports.SortNodeSchema).optional().describe('ORDER BY specification'),
+    frame: zod_1.z.object({
+        type: zod_1.z.enum(['rows', 'range']).optional(),
+        start: zod_1.z.string().optional().describe('Frame start (e.g., "UNBOUNDED PRECEDING", "1 PRECEDING")'),
+        end: zod_1.z.string().optional().describe('Frame end (e.g., "CURRENT ROW", "1 FOLLOWING")'),
+    }).optional().describe('Window frame specification'),
+});
+/**
+ * Window Function Node
+ * Represents window function with OVER clause.
+ */
+exports.WindowFunctionNodeSchema = zod_1.z.object({
+    function: exports.WindowFunction.describe('Window function name'),
+    field: zod_1.z.string().optional().describe('Field to operate on (for aggregate window functions)'),
+    alias: zod_1.z.string().describe('Result column alias'),
+    over: exports.WindowSpecSchema.describe('Window specification (OVER clause)'),
+});
+/**
+ * Field Selection Node
+ * Represents "Select" attributes, including joins.
+ */
+exports.FieldNodeSchema = zod_1.z.lazy(() => zod_1.z.union([
+    zod_1.z.string(), // Primitive field: "name"
+    zod_1.z.object({
+        field: zod_1.z.string(), // Relationship field: "owner"
+        fields: zod_1.z.array(exports.FieldNodeSchema).optional(), // Nested select: ["name", "email"]
+        alias: zod_1.z.string().optional()
+    })
+]));
+/**
+ * Query AST Schema
+ * The universal data retrieval contract defined in `ast-structure.mdx`.
+ */
+exports.QuerySchema = zod_1.z.object({
+    /** Target Entity */
+    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'),
+    /** Joins */
+    joins: zod_1.z.array(exports.JoinNodeSchema).optional().describe('Table joins'),
+    /** 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'),
+    /** Subquery flag */
+    distinct: zod_1.z.boolean().optional().describe('SELECT DISTINCT flag'),
+});

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

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+/**
+ * Sharing Rule Type
+ * How is the data shared?
+ */
+export declare const SharingRuleType: z.ZodEnum<["owner", "criteria", "manual", "guest"]>;
+/**
+ * Sharing Level
+ * What access is granted?
+ */
+export declare const SharingLevel: z.ZodEnum<["read", "edit"]>;
+/**
+ * Sharing Rule Schema
+ * Defines AUTOMATIC access grants based on logic.
+ * The core engine of the governance layer.
+ */
+export declare const SharingRuleSchema: z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    active: z.ZodDefault<z.ZodBoolean>;
+    /** Target Object */
+    object: z.ZodString;
+    /** Grant Logic */
+    type: z.ZodDefault<z.ZodEnum<["owner", "criteria", "manual", "guest"]>>;
+    /**
+     * Criteria (for type='criteria')
+     * SQL-like condition: "department = 'Sales' AND amount > 10000"
+     */
+    criteria: z.ZodOptional<z.ZodString>;
+    /** Access Level */
+    accessLevel: z.ZodDefault<z.ZodEnum<["read", "edit"]>>;
+    /**
+     * Target Audience (Whom to share with)
+     * ID of a Group, Role, or User.
+     */
+    sharedWith: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    type: "owner" | "criteria" | "manual" | "guest";
+    name: string;
+    active: boolean;
+    accessLevel: "read" | "edit";
+    sharedWith: string;
+    label?: string | undefined;
+    criteria?: string | undefined;
+}, {
+    object: string;
+    name: string;
+    sharedWith: string;
+    type?: "owner" | "criteria" | "manual" | "guest" | undefined;
+    label?: string | undefined;
+    active?: boolean | undefined;
+    criteria?: string | undefined;
+    accessLevel?: "read" | "edit" | undefined;
+}>;
+/**
+ * Organization-Wide Defaults (OWD)
+ * The baseline security posture for an object.
+ */
+export declare const OWDModel: z.ZodEnum<["private", "public_read", "public_read_write"]>;
+export type SharingRule = z.infer<typeof SharingRuleSchema>;
+export type SharingRuleType = z.infer<typeof SharingRuleType>;
+//# sourceMappingURL=sharing.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sharing.zod.d.ts","sourceRoot":"","sources":["../../src/data/sharing.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,eAAe,qDAK1B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,YAAY,6BAGvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;IAK5B,oBAAoB;;IAGpB,kBAAkB;;IAGlB;;;OAGG;;IAGH,mBAAmB;;IAGnB;;;OAGG;;;;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,QAAQ,4DAInB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}