@objectstack/spec 0.3.2 → 0.3.3

package/dist/kernel/plugin.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.zod.d.ts","sourceRoot":"","sources":["../../src/kernel/plugin.zod.ts"],"names":[],"mappings":"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"}

package/dist/{system → kernel}/plugin.zod.js

@@ -120,6 +120,19 @@ exports.PluginContextSchema = zod_1.z.object({
         router: exports.RouterSchema,
         scheduler: exports.SchedulerSchema.optional(),
     }).describe('App Runtime Capabilities'),
+    /**
+     * Driver Registry.
+     * Allows plugins to register new storage drivers.
+     *
+     * @example
+     * context.drivers.register(new MongoDriver());
+     */
+    drivers: zod_1.z.object({
+        register: zod_1.z.function()
+            //.args(DriverInterfaceSchema) // Avoid circular dependency, use any or runtime check
+            .args(zod_1.z.any())
+            .describe('Register a new driver instance'),
+    }).describe('Driver Management'),
 });
 /**
  * Plugin Lifecycle Schema

package/dist/kernel/scoped-storage.zod.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+/**
+ * Storage Scope Enum
+ * Defines the lifecycle and persistence guarantee of the storage area.
+ */
+export declare const StorageScope: z.ZodEnum<["temp", "cache", "data", "logs", "config", "public"]>;
+export type StorageScope = z.infer<typeof StorageScope>;
+/**
+ * Storage Adapter Type
+ */
+export declare const StorageAdapterType: z.ZodEnum<["local", "memory", "s3", "gcs", "azure", "gridfs"]>;
+/**
+ * Scoped Storage Configuration
+ * How the Kernel maps a logical scope to a physical backend.
+ */
+export declare const ScopedStorageConfigSchema: z.ZodObject<{
+    /**
+     * The scope identifier
+     */
+    scope: z.ZodEnum<["temp", "cache", "data", "logs", "config", "public"]>;
+    /**
+     * The backend driver
+     */
+    adapter: z.ZodDefault<z.ZodEnum<["local", "memory", "s3", "gcs", "azure", "gridfs"]>>;
+    /**
+     * Base path or bucket name
+     */
+    location: z.ZodString;
+    /**
+     * Adapter specific configuration
+     */
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    /**
+     * Quota in bytes (optional)
+     */
+    quota: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    location: string;
+    scope: "data" | "config" | "public" | "temp" | "cache" | "logs";
+    adapter: "s3" | "gcs" | "local" | "memory" | "azure" | "gridfs";
+    options?: Record<string, any> | undefined;
+    quota?: number | undefined;
+}, {
+    location: string;
+    scope: "data" | "config" | "public" | "temp" | "cache" | "logs";
+    options?: Record<string, any> | undefined;
+    adapter?: "s3" | "gcs" | "local" | "memory" | "azure" | "gridfs" | undefined;
+    quota?: number | undefined;
+}>;
+export type ScopedStorageConfig = z.infer<typeof ScopedStorageConfigSchema>;
+/**
+ * File Metadata Schema
+ * Standardized file attribute structure
+ */
+export declare const FileMetadataSchema: z.ZodObject<{
+    path: z.ZodString;
+    name: z.ZodString;
+    size: z.ZodNumber;
+    mimeType: z.ZodString;
+    lastModified: z.ZodString;
+    created: z.ZodString;
+    etag: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    name: string;
+    size: number;
+    mimeType: string;
+    lastModified: string;
+    created: string;
+    etag?: string | undefined;
+}, {
+    path: string;
+    name: string;
+    size: number;
+    mimeType: string;
+    lastModified: string;
+    created: string;
+    etag?: string | undefined;
+}>;
+export type FileMetadata = z.infer<typeof FileMetadataSchema>;
+//# sourceMappingURL=scoped-storage.zod.d.ts.map

package/dist/kernel/scoped-storage.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-storage.zod.d.ts","sourceRoot":"","sources":["../../src/kernel/scoped-storage.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,YAAY,kEAO0B,CAAC;AAEpD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;GAEG;AACH,eAAO,MAAM,kBAAkB,gEAO7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,yBAAyB;IACpC;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;EAQ7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/kernel/scoped-storage.zod.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileMetadataSchema = exports.ScopedStorageConfigSchema = exports.StorageAdapterType = exports.StorageScope = void 0;
+const zod_1 = require("zod");
+/**
+ * Storage Scope Enum
+ * Defines the lifecycle and persistence guarantee of the storage area.
+ */
+exports.StorageScope = zod_1.z.enum([
+    'temp', // Ephemeral, cleared on restart
+    'cache', // Ephemeral, survives restarts, cleared on LRU/Expiration
+    'data', // Persistent, backed up
+    'logs', // Append-only, rotated
+    'config', // Read-heavy, versioned
+    'public' // Publicly accessible static assets
+]).describe('Generic storage scope classification');
+/**
+ * Storage Adapter Type
+ */
+exports.StorageAdapterType = zod_1.z.enum([
+    'local', // Local filesystem
+    'memory', // In-memory (for testing/temp)
+    's3', // S3 compatible object storage
+    'gcs', // Google Cloud Storage
+    'azure', // Azure Blob Storage
+    'gridfs' // MongoDB GridFS
+]);
+/**
+ * Scoped Storage Configuration
+ * How the Kernel maps a logical scope to a physical backend.
+ */
+exports.ScopedStorageConfigSchema = zod_1.z.object({
+    /**
+     * The scope identifier
+     */
+    scope: exports.StorageScope,
+    /**
+     * The backend driver
+     */
+    adapter: exports.StorageAdapterType.default('local'),
+    /**
+     * Base path or bucket name
+     */
+    location: zod_1.z.string().describe('Root path (local) or Bucket name (remote)'),
+    /**
+     * Adapter specific configuration
+     */
+    options: zod_1.z.record(zod_1.z.any()).optional().describe('Driver specific options (region, endpoint, etc)'),
+    /**
+     * Quota in bytes (optional)
+     */
+    quota: zod_1.z.number().int().positive().optional().describe('Max size in bytes'),
+});
+/**
+ * File Metadata Schema
+ * Standardized file attribute structure
+ */
+exports.FileMetadataSchema = zod_1.z.object({
+    path: zod_1.z.string(),
+    name: zod_1.z.string(),
+    size: zod_1.z.number().int(),
+    mimeType: zod_1.z.string(),
+    lastModified: zod_1.z.string().datetime(),
+    created: zod_1.z.string().datetime(),
+    etag: zod_1.z.string().optional(),
+});

package/dist/permission/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Data Protocol Exports
+ *
+ * Core Business Logic & Data Modeling
+ * - Object, Field, Validation
+ * - Query (AST), Mapping (ETL)
+ * - Permission, Sharing, Flow
+ */
+export * from './permission.zod';
+export * from './sharing.zod';
+export * from './territory.zod';
+//# sourceMappingURL=index.d.ts.map

package/dist/permission/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/permission/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/dist/permission/index.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Data Protocol Exports
+ *
+ * Core Business Logic & Data Modeling
+ * - Object, Field, Validation
+ * - Query (AST), Mapping (ETL)
+ * - Permission, Sharing, Flow
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./permission.zod"), exports);
+__exportStar(require("./sharing.zod"), exports);
+__exportStar(require("./territory.zod"), exports);

package/dist/{data → permission}/permission.zod.d.ts

@@ -1,7 +1,12 @@
 import { z } from 'zod';
 /**
  * Entity (Object) Level Permissions
- * Defines CRUD + VAMA (View All / Modify All) access.
+ * Defines CRUD + VAMA (View All / Modify All) + Lifecycle access.
+ *
+ * Refined with enterprise data lifecycle controls:
+ * - Transfer (Ownership change)
+ * - Restore (Soft delete recovery)
+ * - Purge (Hard delete / Compliance)
  */
 export declare const ObjectPermissionSchema: z.ZodObject<{
     /** C: Create */
@@ -12,6 +17,10 @@ export declare const ObjectPermissionSchema: z.ZodObject<{
     allowEdit: z.ZodDefault<z.ZodBoolean>;
     /** D: Delete (Owned records or Shared records) */
     allowDelete: z.ZodDefault<z.ZodBoolean>;
+    /** Lifecycle Operations */
+    allowTransfer: z.ZodDefault<z.ZodBoolean>;
+    allowRestore: z.ZodDefault<z.ZodBoolean>;
+    allowPurge: z.ZodDefault<z.ZodBoolean>;
     /**
      * View All Records: Super-user read access.
      * Bypasses Sharing Rules and Ownership checks.
@@ -29,6 +38,9 @@ export declare const ObjectPermissionSchema: z.ZodObject<{
     allowRead: boolean;
     allowEdit: boolean;
     allowDelete: boolean;
+    allowTransfer: boolean;
+    allowRestore: boolean;
+    allowPurge: boolean;
     viewAllRecords: boolean;
     modifyAllRecords: boolean;
 }, {
@@ -36,6 +48,9 @@ export declare const ObjectPermissionSchema: z.ZodObject<{
     allowRead?: boolean | undefined;
     allowEdit?: boolean | undefined;
     allowDelete?: boolean | undefined;
+    allowTransfer?: boolean | undefined;
+    allowRestore?: boolean | undefined;
+    allowPurge?: boolean | undefined;
     viewAllRecords?: boolean | undefined;
     modifyAllRecords?: boolean | undefined;
 }>;
@@ -80,6 +95,10 @@ export declare const PermissionSetSchema: z.ZodObject<{
         allowEdit: z.ZodDefault<z.ZodBoolean>;
         /** D: Delete (Owned records or Shared records) */
         allowDelete: z.ZodDefault<z.ZodBoolean>;
+        /** Lifecycle Operations */
+        allowTransfer: z.ZodDefault<z.ZodBoolean>;
+        allowRestore: z.ZodDefault<z.ZodBoolean>;
+        allowPurge: z.ZodDefault<z.ZodBoolean>;
         /**
          * View All Records: Super-user read access.
          * Bypasses Sharing Rules and Ownership checks.
@@ -97,6 +116,9 @@ export declare const PermissionSetSchema: z.ZodObject<{
         allowRead: boolean;
         allowEdit: boolean;
         allowDelete: boolean;
+        allowTransfer: boolean;
+        allowRestore: boolean;
+        allowPurge: boolean;
         viewAllRecords: boolean;
         modifyAllRecords: boolean;
     }, {
@@ -104,6 +126,9 @@ export declare const PermissionSetSchema: z.ZodObject<{
         allowRead?: boolean | undefined;
         allowEdit?: boolean | undefined;
         allowDelete?: boolean | undefined;
+        allowTransfer?: boolean | undefined;
+        allowRestore?: boolean | undefined;
+        allowPurge?: boolean | undefined;
         viewAllRecords?: boolean | undefined;
         modifyAllRecords?: boolean | undefined;
     }>>;
@@ -130,14 +155,17 @@ export declare const PermissionSetSchema: z.ZodObject<{
         allowRead: boolean;
         allowEdit: boolean;
         allowDelete: boolean;
+        allowTransfer: boolean;
+        allowRestore: boolean;
+        allowPurge: boolean;
         viewAllRecords: boolean;
         modifyAllRecords: boolean;
     }>;
-    label?: string | undefined;
     fields?: Record<string, {
         readable: boolean;
         editable: boolean;
     }> | undefined;
+    label?: string | undefined;
     systemPermissions?: string[] | undefined;
 }, {
     name: string;
@@ -146,14 +174,17 @@ export declare const PermissionSetSchema: z.ZodObject<{
         allowRead?: boolean | undefined;
         allowEdit?: boolean | undefined;
         allowDelete?: boolean | undefined;
+        allowTransfer?: boolean | undefined;
+        allowRestore?: boolean | undefined;
+        allowPurge?: boolean | undefined;
         viewAllRecords?: boolean | undefined;
         modifyAllRecords?: boolean | undefined;
     }>;
-    label?: string | undefined;
     fields?: Record<string, {
         readable?: boolean | undefined;
         editable?: boolean | undefined;
     }> | undefined;
+    label?: string | undefined;
     isProfile?: boolean | undefined;
     systemPermissions?: string[] | undefined;
 }>;

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

@@ -0,0 +1 @@
+{"version":3,"file":"permission.zod.d.ts","sourceRoot":"","sources":["../../src/permission/permission.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;IACjC,gBAAgB;;IAEhB,gDAAgD;;IAEhD,gDAAgD;;IAEhD,kDAAkD;;IAGlD,2BAA2B;;;;IAK3B;;;;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;;QA1D3D,gBAAgB;;QAEhB,gDAAgD;;QAEhD,gDAAgD;;QAEhD,kDAAkD;;QAGlD,2BAA2B;;;;QAK3B;;;;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}/permission.zod.js

@@ -4,7 +4,12 @@ exports.PermissionSetSchema = exports.FieldPermissionSchema = exports.ObjectPerm
 const zod_1 = require("zod");
 /**
  * Entity (Object) Level Permissions
- * Defines CRUD + VAMA (View All / Modify All) access.
+ * Defines CRUD + VAMA (View All / Modify All) + Lifecycle access.
+ *
+ * Refined with enterprise data lifecycle controls:
+ * - Transfer (Ownership change)
+ * - Restore (Soft delete recovery)
+ * - Purge (Hard delete / Compliance)
  */
 exports.ObjectPermissionSchema = zod_1.z.object({
     /** C: Create */
@@ -15,6 +20,10 @@ exports.ObjectPermissionSchema = zod_1.z.object({
     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'),
+    /** Lifecycle Operations */
+    allowTransfer: zod_1.z.boolean().default(false).describe('Change record ownership'),
+    allowRestore: zod_1.z.boolean().default(false).describe('Restore from trash (Undelete)'),
+    allowPurge: zod_1.z.boolean().default(false).describe('Permanently delete (Hard Delete/GDPR)'),
     /**
      * View All Records: Super-user read access.
      * Bypasses Sharing Rules and Ownership checks.

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

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+/**
+ * Organization-Wide Defaults (OWD)
+ * The baseline security posture for an object.
+ */
+export declare const OWDModel: z.ZodEnum<["private", "public_read", "public_read_write", "controlled_by_parent"]>;
+/**
+ * Sharing Rule Type
+ * How is the data shared?
+ */
+export declare const SharingRuleType: z.ZodEnum<["owner", "criteria"]>;
+/**
+ * Sharing Level
+ * What access is granted?
+ */
+export declare const SharingLevel: z.ZodEnum<["read", "edit", "full"]>;
+/**
+ * Recipient Type
+ * Who receives the access?
+ */
+export declare const ShareRecipientType: z.ZodEnum<["user", "group", "role", "role_and_subordinates", "guest"]>;
+/**
+ * 1. Criteria-Based Sharing Rule
+ * Share records that meet specific field criteria.
+ */
+export declare const CriteriaSharingRuleSchema: z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    object: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    accessLevel: z.ZodDefault<z.ZodEnum<["read", "edit", "full"]>>;
+    sharedWith: z.ZodObject<{
+        type: z.ZodEnum<["user", "group", "role", "role_and_subordinates", "guest"]>;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        type: "user" | "group" | "role" | "role_and_subordinates" | "guest";
+    }, {
+        value: string;
+        type: "user" | "group" | "role" | "role_and_subordinates" | "guest";
+    }>;
+} & {
+    type: z.ZodLiteral<"criteria">;
+    condition: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    type: "criteria";
+    name: string;
+    active: boolean;
+    condition: string;
+    accessLevel: "full" | "read" | "edit";
+    sharedWith: {
+        value: string;
+        type: "user" | "group" | "role" | "role_and_subordinates" | "guest";
+    };
+    label?: string | undefined;
+    description?: string | undefined;
+}, {
+    object: string;
+    type: "criteria";
+    name: string;
+    condition: string;
+    sharedWith: {
+        value: string;
+        type: "user" | "group" | "role" | "role_and_subordinates" | "guest";
+    };
+    label?: string | undefined;
+    description?: string | undefined;
+    active?: boolean | undefined;
+    accessLevel?: "full" | "read" | "edit" | undefined;
+}>;
+/**
+ * 2. Owner-Based Sharing Rule
+ * Share records owned by a specific group of users.
+ */
+export declare const OwnerSharingRuleSchema: z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    object: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    accessLevel: z.ZodDefault<z.ZodEnum<["read", "edit", "full"]>>;
+    sharedWith: z.ZodObject<{
+        type: z.ZodEnum<["user", "group", "role", "role_and_subordinates", "guest"]>;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        type: "user" | "group" | "role" | "role_and_subordinates" | "guest";
+    }, {
+        value: string;
+        type: "user" | "group" | "role" | "role_and_subordinates" | "guest";
+    }>;
+} & {
+    type: z.ZodLiteral<"owner">;
+    ownedBy: z.ZodObject<{
+        type: z.ZodEnum<["user", "group", "role", "role_and_subordinates", "guest"]>;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        type: "user" | "group" | "role" | "role_and_subordinates" | "guest";
+    }, {
+        value: string;
+        type: "user" | "group" | "role" | "role_and_subordinates" | "guest";
+    }>;
+}, "strip", z.ZodTypeAny, {
+    object: string;
+    type: "owner";
+    name: string;
+    active: boolean;
+    accessLevel: "full" | "read" | "edit";
+    sharedWith: {
+        value: string;
+        type: "user" | "group" | "role" | "role_and_subordinates" | "guest";
+    };
+    ownedBy: {
+        value: string;
+        type: "user" | "group" | "role" | "role_and_subordinates" | "guest";
+    };
+    label?: string | undefined;
+    description?: string | undefined;
+}, {
+    object: string;
+    type: "owner";
+    name: string;
+    sharedWith: {
+        value: string;
+        type: "user" | "group" | "role" | "role_and_subordinates" | "guest";
+    };
+    ownedBy: {
+        value: string;
+        type: "user" | "group" | "role" | "role_and_subordinates" | "guest";
+    };
+    label?: string | undefined;
+    description?: string | undefined;
+    active?: boolean | undefined;
+    accessLevel?: "full" | "read" | "edit" | undefined;
+}>;
+/**
+ * Master Sharing Rule Schema
+ */
+export declare const SharingRuleSchema: z.ZodType<any>;
+export type SharingRule = z.infer<typeof SharingRuleSchema>;
+export type CriteriaSharingRule = z.infer<typeof CriteriaSharingRuleSchema>;
+export type OwnerSharingRule = z.infer<typeof OwnerSharingRuleSchema>;
+//# sourceMappingURL=sharing.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sharing.zod.d.ts","sourceRoot":"","sources":["../../src/permission/sharing.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,QAAQ,oFAKnB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe,kCAG1B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,YAAY,qCAIvB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB,wEAM7B,CAAC;AA0BH;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAG3C,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/permission/sharing.zod.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharingRuleSchema = exports.OwnerSharingRuleSchema = exports.CriteriaSharingRuleSchema = exports.ShareRecipientType = exports.SharingLevel = exports.SharingRuleType = exports.OWDModel = void 0;
+const zod_1 = require("zod");
+/**
+ * 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
+    'controlled_by_parent' // Access derived from parent record (Master-Detail)
+]);
+/**
+ * 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')
+]);
+/**
+ * Sharing Level
+ * What access is granted?
+ */
+exports.SharingLevel = zod_1.z.enum([
+    'read', // Read Only
+    'edit', // Read / Write
+    'full' // Full Access (Transfer, Share, Delete)
+]);
+/**
+ * Recipient Type
+ * Who receives the access?
+ */
+exports.ShareRecipientType = zod_1.z.enum([
+    'user',
+    'group',
+    'role',
+    'role_and_subordinates',
+    'guest' // for public sharing
+]);
+/**
+ * Base Sharing Rule
+ * Common metadata for all sharing strategies.
+ */
+const BaseSharingRuleSchema = zod_1.z.object({
+    // Identification
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Unique rule name (snake_case)'),
+    label: zod_1.z.string().optional().describe('Human-readable label'),
+    description: zod_1.z.string().optional().describe('Administrative notes'),
+    // Scope
+    object: zod_1.z.string().describe('Target Object Name'),
+    active: zod_1.z.boolean().default(true),
+    // Access
+    accessLevel: exports.SharingLevel.default('read'),
+    // Recipient (Whom to share with)
+    sharedWith: zod_1.z.object({
+        type: exports.ShareRecipientType,
+        value: zod_1.z.string().describe('ID or Code of the User/Group/Role'),
+    }).describe('The recipient of the shared access'),
+});
+/**
+ * 1. Criteria-Based Sharing Rule
+ * Share records that meet specific field criteria.
+ */
+exports.CriteriaSharingRuleSchema = BaseSharingRuleSchema.extend({
+    type: zod_1.z.literal('criteria'),
+    condition: zod_1.z.string().describe('Formula condition (e.g. "department = \'Sales\'")'),
+});
+/**
+ * 2. Owner-Based Sharing Rule
+ * Share records owned by a specific group of users.
+ */
+exports.OwnerSharingRuleSchema = BaseSharingRuleSchema.extend({
+    type: zod_1.z.literal('owner'),
+    ownedBy: zod_1.z.object({
+        type: exports.ShareRecipientType,
+        value: zod_1.z.string(),
+    }).describe('Source group/role whose records are being shared'),
+});
+/**
+ * Master Sharing Rule Schema
+ */
+exports.SharingRuleSchema = zod_1.z.discriminatedUnion('type', [
+    exports.CriteriaSharingRuleSchema,
+    exports.OwnerSharingRuleSchema
+]);

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

@@ -0,0 +1 @@
+{"version":3,"file":"territory.zod.d.ts","sourceRoot":"","sources":["../../src/permission/territory.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,aAAa,uEAKxB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAK/B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe;IAC1B,eAAe;;;IAIf,gBAAgB;;;;IAKhB;;;;OAIG;;IAGH;;;OAGG;;IAGH,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;EAInB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}