@objectstack/spec 0.1.0 → 0.1.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"object.zod.d.ts","sourceRoot":"","sources":["../../src/data/object.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,kBAAkB;IAC7B,4CAA4C;;IAG5C,oCAAoC;;IAGpC,qCAAqC;;IAGrC,+BAA+B;;IAG/B,iCAAiC;;IAGjC,mCAAmC;;;;;;;;;;;;;;;;EAEnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;EAItB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;IACvB,eAAe;;;;;;IAOf,qBAAqB;;;;IAKrB,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGxB,cAAc;;;;;;;;;;;;;;IAGd,iBAAiB;;IAGjB,8BAA8B;;QArD9B,4CAA4C;;QAG5C,oCAAoC;;QAGpC,qCAAqC;;QAGrC,+BAA+B;;QAG/B,iCAAiC;;QAGjC,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCnC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/data/object.zod.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectSchema = exports.IndexSchema = exports.ObjectCapabilities = void 0;
+const zod_1 = require("zod");
+const field_zod_1 = require("./field.zod");
+/**
+ * Capability Flags
+ * Defines what system features are enabled for this object.
+ */
+exports.ObjectCapabilities = zod_1.z.object({
+    /** Enable history tracking (Audit Trail) */
+    trackHistory: zod_1.z.boolean().default(false),
+    /** Enable global search indexing */
+    searchable: zod_1.z.boolean().default(true),
+    /** Enable REST/GraphQL API access */
+    apiEnabled: zod_1.z.boolean().default(true),
+    /** Enable attachments/files */
+    files: zod_1.z.boolean().default(false),
+    /** Enable discussions/chatter */
+    feedEnabled: zod_1.z.boolean().default(false),
+    /** Enable Recycle Bin mechanics */
+    trash: zod_1.z.boolean().default(true),
+});
+/**
+ * Schema for database indexes.
+ */
+exports.IndexSchema = zod_1.z.object({
+    name: zod_1.z.string().optional().describe('Index name'),
+    fields: zod_1.z.array(zod_1.z.string()).describe('Fields included in the index'),
+    unique: zod_1.z.boolean().optional().describe('Whether the index is unique'),
+});
+/**
+ * Object Schema - Enterprise Data Model
+ */
+exports.ObjectSchema = zod_1.z.object({
+    /** Identify */
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Machine name (snake_case)'),
+    label: zod_1.z.string().optional().describe('Singular Label (e.g. "Account")'),
+    pluralLabel: zod_1.z.string().optional().describe('Plural Label (e.g. "Accounts")'),
+    description: zod_1.z.string().optional().describe('Internal description'),
+    icon: zod_1.z.string().optional().describe('Lucide icon name'),
+    /** Storage Config */
+    datasource: zod_1.z.string().default('default').describe('Datasource name'),
+    tableName: zod_1.z.string().optional().describe('Physical DB table override'),
+    isSystem: zod_1.z.boolean().default(false).describe('Is system object (protected)'),
+    /** Fields Definition */
+    fields: zod_1.z.record(field_zod_1.FieldSchema).describe('Map of field definitions'),
+    /** Indexes */
+    indexes: zod_1.z.array(exports.IndexSchema).optional().describe('Database indexes definition'),
+    /** Key Fields */
+    nameField: zod_1.z.string().optional().describe('Which field represents the record name/title (usually "name")'),
+    /** Features & Capabilities */
+    enable: exports.ObjectCapabilities.optional().describe('Enabled system capabilities'),
+});

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

@@ -0,0 +1,163 @@
+import { z } from 'zod';
+/**
+ * Entity (Object) Level Permissions
+ * Defines CRUD + VAMA (View All / Modify All) access.
+ */
+export declare const ObjectPermissionSchema: z.ZodObject<{
+    /** C: Create */
+    allowCreate: z.ZodDefault<z.ZodBoolean>;
+    /** R: Read (Owned records or Shared records) */
+    allowRead: z.ZodDefault<z.ZodBoolean>;
+    /** U: Edit (Owned records or Shared records) */
+    allowEdit: z.ZodDefault<z.ZodBoolean>;
+    /** D: Delete (Owned records or Shared records) */
+    allowDelete: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * View All Records: Super-user read access.
+     * Bypasses Sharing Rules and Ownership checks.
+     * Equivalent to Microsoft Dataverse "Organization" level read access.
+     */
+    viewAllRecords: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Modify All Records: Super-user write access.
+     * Bypasses Sharing Rules and Ownership checks.
+     * Equivalent to Microsoft Dataverse "Organization" level write access.
+     */
+    modifyAllRecords: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    allowCreate: boolean;
+    allowRead: boolean;
+    allowEdit: boolean;
+    allowDelete: boolean;
+    viewAllRecords: boolean;
+    modifyAllRecords: boolean;
+}, {
+    allowCreate?: boolean | undefined;
+    allowRead?: boolean | undefined;
+    allowEdit?: boolean | undefined;
+    allowDelete?: boolean | undefined;
+    viewAllRecords?: boolean | undefined;
+    modifyAllRecords?: boolean | undefined;
+}>;
+/**
+ * Field Level Security (FLS)
+ */
+export declare const FieldPermissionSchema: z.ZodObject<{
+    /** Can see this field */
+    readable: z.ZodDefault<z.ZodBoolean>;
+    /** Can edit this field */
+    editable: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    readable: boolean;
+    editable: boolean;
+}, {
+    readable?: boolean | undefined;
+    editable?: boolean | undefined;
+}>;
+/**
+ * Permission Set Schema
+ * Defines a collection of permissions that can be assigned to users.
+ *
+ * DIFFERENTIATION:
+ * - Profile: The ONE primary functional definition of a user (e.g. Standard User).
+ * - Permission Set: Add-on capabilities assigned to users (e.g. Export Reports).
+ * - Role: (Defined in src/system/role.zod.ts) Defines data visibility hierarchy.
+ */
+export declare const PermissionSetSchema: z.ZodObject<{
+    /** Unique permission set name */
+    name: z.ZodString;
+    /** Display label */
+    label: z.ZodOptional<z.ZodString>;
+    /** Is this a Profile? (Base set for a user) */
+    isProfile: z.ZodDefault<z.ZodBoolean>;
+    /** Object Permissions Map: <entity_name> -> permissions */
+    objects: z.ZodRecord<z.ZodString, z.ZodObject<{
+        /** C: Create */
+        allowCreate: z.ZodDefault<z.ZodBoolean>;
+        /** R: Read (Owned records or Shared records) */
+        allowRead: z.ZodDefault<z.ZodBoolean>;
+        /** U: Edit (Owned records or Shared records) */
+        allowEdit: z.ZodDefault<z.ZodBoolean>;
+        /** D: Delete (Owned records or Shared records) */
+        allowDelete: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * View All Records: Super-user read access.
+         * Bypasses Sharing Rules and Ownership checks.
+         * Equivalent to Microsoft Dataverse "Organization" level read access.
+         */
+        viewAllRecords: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Modify All Records: Super-user write access.
+         * Bypasses Sharing Rules and Ownership checks.
+         * Equivalent to Microsoft Dataverse "Organization" level write access.
+         */
+        modifyAllRecords: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        allowCreate: boolean;
+        allowRead: boolean;
+        allowEdit: boolean;
+        allowDelete: boolean;
+        viewAllRecords: boolean;
+        modifyAllRecords: boolean;
+    }, {
+        allowCreate?: boolean | undefined;
+        allowRead?: boolean | undefined;
+        allowEdit?: boolean | undefined;
+        allowDelete?: boolean | undefined;
+        viewAllRecords?: boolean | undefined;
+        modifyAllRecords?: boolean | undefined;
+    }>>;
+    /** Field Permissions Map: <entity_name>.<field_name> -> permissions */
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        /** Can see this field */
+        readable: z.ZodDefault<z.ZodBoolean>;
+        /** Can edit this field */
+        editable: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        readable: boolean;
+        editable: boolean;
+    }, {
+        readable?: boolean | undefined;
+        editable?: boolean | undefined;
+    }>>>;
+    /** System permissions (e.g., "manage_users") */
+    systemPermissions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    isProfile: boolean;
+    objects: Record<string, {
+        allowCreate: boolean;
+        allowRead: boolean;
+        allowEdit: boolean;
+        allowDelete: boolean;
+        viewAllRecords: boolean;
+        modifyAllRecords: boolean;
+    }>;
+    label?: string | undefined;
+    fields?: Record<string, {
+        readable: boolean;
+        editable: boolean;
+    }> | undefined;
+    systemPermissions?: string[] | undefined;
+}, {
+    name: string;
+    objects: Record<string, {
+        allowCreate?: boolean | undefined;
+        allowRead?: boolean | undefined;
+        allowEdit?: boolean | undefined;
+        allowDelete?: boolean | undefined;
+        viewAllRecords?: boolean | undefined;
+        modifyAllRecords?: boolean | undefined;
+    }>;
+    label?: string | undefined;
+    fields?: Record<string, {
+        readable?: boolean | undefined;
+        editable?: boolean | undefined;
+    }> | undefined;
+    isProfile?: boolean | undefined;
+    systemPermissions?: string[] | undefined;
+}>;
+export type PermissionSet = z.infer<typeof PermissionSetSchema>;
+export type ObjectPermission = z.infer<typeof ObjectPermissionSchema>;
+export type FieldPermission = z.infer<typeof FieldPermissionSchema>;
+//# sourceMappingURL=permission.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permission.zod.d.ts","sourceRoot":"","sources":["../../src/data/permission.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,sBAAsB;IACjC,gBAAgB;;IAEhB,gDAAgD;;IAEhD,gDAAgD;;IAEhD,kDAAkD;;IAGlD;;;;OAIG;;IAGH;;;;OAIG;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;IAChC,yBAAyB;;IAEzB,0BAA0B;;;;;;;;EAE1B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;IAC9B,iCAAiC;;IAGjC,oBAAoB;;IAGpB,+CAA+C;;IAG/C,2DAA2D;;QArD3D,gBAAgB;;QAEhB,gDAAgD;;QAEhD,gDAAgD;;QAEhD,kDAAkD;;QAGlD;;;;WAIG;;QAGH;;;;WAIG;;;;;;;;;;;;;;;;;IAoCH,uEAAuE;;QA5BvE,yBAAyB;;QAEzB,0BAA0B;;;;;;;;;IA6B1B,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEhD,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/data/permission.zod.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionSetSchema = exports.FieldPermissionSchema = exports.ObjectPermissionSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Entity (Object) Level Permissions
+ * Defines CRUD + VAMA (View All / Modify All) access.
+ */
+exports.ObjectPermissionSchema = zod_1.z.object({
+    /** C: Create */
+    allowCreate: zod_1.z.boolean().default(false).describe('Create permission'),
+    /** R: Read (Owned records or Shared records) */
+    allowRead: zod_1.z.boolean().default(false).describe('Read permission'),
+    /** U: Edit (Owned records or Shared records) */
+    allowEdit: zod_1.z.boolean().default(false).describe('Edit permission'),
+    /** D: Delete (Owned records or Shared records) */
+    allowDelete: zod_1.z.boolean().default(false).describe('Delete permission'),
+    /**
+     * View All Records: Super-user read access.
+     * Bypasses Sharing Rules and Ownership checks.
+     * Equivalent to Microsoft Dataverse "Organization" level read access.
+     */
+    viewAllRecords: zod_1.z.boolean().default(false).describe('View All Data (Bypass Sharing)'),
+    /**
+     * Modify All Records: Super-user write access.
+     * Bypasses Sharing Rules and Ownership checks.
+     * Equivalent to Microsoft Dataverse "Organization" level write access.
+     */
+    modifyAllRecords: zod_1.z.boolean().default(false).describe('Modify All Data (Bypass Sharing)'),
+});
+/**
+ * Field Level Security (FLS)
+ */
+exports.FieldPermissionSchema = zod_1.z.object({
+    /** Can see this field */
+    readable: zod_1.z.boolean().default(true).describe('Field read access'),
+    /** Can edit this field */
+    editable: zod_1.z.boolean().default(false).describe('Field edit access'),
+});
+/**
+ * Permission Set Schema
+ * Defines a collection of permissions that can be assigned to users.
+ *
+ * DIFFERENTIATION:
+ * - Profile: The ONE primary functional definition of a user (e.g. Standard User).
+ * - Permission Set: Add-on capabilities assigned to users (e.g. Export Reports).
+ * - Role: (Defined in src/system/role.zod.ts) Defines data visibility hierarchy.
+ */
+exports.PermissionSetSchema = zod_1.z.object({
+    /** Unique permission set name */
+    name: zod_1.z.string().describe('Permission set unique name'),
+    /** Display label */
+    label: zod_1.z.string().optional().describe('Display label'),
+    /** Is this a Profile? (Base set for a user) */
+    isProfile: zod_1.z.boolean().default(false).describe('Whether this is a user profile'),
+    /** Object Permissions Map: <entity_name> -> permissions */
+    objects: zod_1.z.record(exports.ObjectPermissionSchema).describe('Entity permissions'),
+    /** Field Permissions Map: <entity_name>.<field_name> -> permissions */
+    fields: zod_1.z.record(exports.FieldPermissionSchema).optional().describe('Field level security'),
+    /** System permissions (e.g., "manage_users") */
+    systemPermissions: zod_1.z.array(zod_1.z.string()).optional().describe('System level capabilities'),
+});

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

@@ -0,0 +1,89 @@
+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;
+}>;
+/**
+ * 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">>;
+    /** Where Clause */
+    filters: 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>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    sort?: {
+        field: string;
+        order: "asc" | "desc";
+    }[] | undefined;
+    fields?: any[] | undefined;
+    filters?: any;
+    top?: number | undefined;
+    skip?: number | undefined;
+}, {
+    object: string;
+    sort?: {
+        field: string;
+        order?: "asc" | "desc" | undefined;
+    }[] | undefined;
+    fields?: any[] | undefined;
+    filters?: any;
+    top?: number | undefined;
+    skip?: number | undefined;
+}>;
+export type QueryAST = z.infer<typeof QuerySchema>;
+export type FilterNode = z.infer<typeof FilterNodeSchema>;
+export type SortNode = z.infer<typeof SortNodeSchema>;
+//# 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,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAS1C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW;IACtB,oBAAoB;;IAGpB,oBAAoB;;IAGpB,mBAAmB;;IAGnB,sBAAsB;;;;;;;;;;;IAGtB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;EAGjB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACnD,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"}

package/dist/data/query.zod.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuerySchema = exports.FieldNodeSchema = 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')
+});
+/**
+ * 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'),
+    /** Where Clause */
+    filters: exports.FilterNodeSchema.optional().describe('Filtering criteria'),
+    /** 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'),
+});

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"}

package/dist/data/sharing.zod.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OWDModel = exports.SharingRuleSchema = exports.SharingLevel = exports.SharingRuleType = void 0;
+const zod_1 = require("zod");
+/**
+ * Sharing Rule Type
+ * How is the data shared?
+ */
+exports.SharingRuleType = zod_1.z.enum([
+    'owner', // Based on record ownership (Role Hierarchy)
+    'criteria', // Based on field values (e.g. Status = 'Open')
+    'manual', // Ad-hoc sharing (User specific)
+    'guest' // Public access
+]);
+/**
+ * Sharing Level
+ * What access is granted?
+ */
+exports.SharingLevel = zod_1.z.enum([
+    'read', // Read Only
+    'edit' // Read / Write
+]);
+/**
+ * Sharing Rule Schema
+ * Defines AUTOMATIC access grants based on logic.
+ * The core engine of the governance layer.
+ */
+exports.SharingRuleSchema = zod_1.z.object({
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Unique rule name'),
+    label: zod_1.z.string().optional(),
+    active: zod_1.z.boolean().default(true),
+    /** Target Object */
+    object: zod_1.z.string().describe('Object to share'),
+    /** Grant Logic */
+    type: exports.SharingRuleType.default('criteria'),
+    /**
+     * Criteria (for type='criteria')
+     * SQL-like condition: "department = 'Sales' AND amount > 10000"
+     */
+    criteria: zod_1.z.string().optional(),
+    /** Access Level */
+    accessLevel: exports.SharingLevel.default('read'),
+    /**
+     * Target Audience (Whom to share with)
+     * ID of a Group, Role, or User.
+     */
+    sharedWith: zod_1.z.string().describe('Group/Role ID to share records with'),
+});
+/**
+ * Organization-Wide Defaults (OWD)
+ * The baseline security posture for an object.
+ */
+exports.OWDModel = zod_1.z.enum([
+    'private', // Only owner can see
+    'public_read', // Everyone can see, owner can edit
+    'public_read_write' // Everyone can see and edit
+]);