@objectstack/spec 0.1.0 → 0.1.1

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

@@ -0,0 +1,236 @@
+import { z } from 'zod';
+/**
+ * 1. Script/Expression Validation
+ * Generic formula-based validation.
+ */
+export declare const ScriptValidationSchema: z.ZodObject<{
+    name: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
+    message: z.ZodString;
+} & {
+    type: z.ZodLiteral<"script">;
+    condition: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "script";
+    name: string;
+    active: boolean;
+    severity: "error" | "warning" | "info";
+    condition: string;
+}, {
+    message: string;
+    type: "script";
+    name: string;
+    condition: string;
+    active?: boolean | undefined;
+    severity?: "error" | "warning" | "info" | undefined;
+}>;
+/**
+ * 2. Uniqueness Validation
+ * specialized optimized check for unique constraints.
+ */
+export declare const UniquenessValidationSchema: z.ZodObject<{
+    name: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
+    message: z.ZodString;
+} & {
+    type: z.ZodLiteral<"unique">;
+    fields: z.ZodArray<z.ZodString, "many">;
+    scope: z.ZodOptional<z.ZodString>;
+    caseSensitive: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "unique";
+    name: string;
+    fields: string[];
+    active: boolean;
+    severity: "error" | "warning" | "info";
+    caseSensitive: boolean;
+    scope?: string | undefined;
+}, {
+    message: string;
+    type: "unique";
+    name: string;
+    fields: string[];
+    active?: boolean | undefined;
+    severity?: "error" | "warning" | "info" | undefined;
+    scope?: string | undefined;
+    caseSensitive?: boolean | undefined;
+}>;
+/**
+ * 3. State Machine Validation
+ * State transition logic.
+ */
+export declare const StateMachineValidationSchema: z.ZodObject<{
+    name: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
+    message: z.ZodString;
+} & {
+    type: z.ZodLiteral<"state_machine">;
+    field: z.ZodString;
+    transitions: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "state_machine";
+    name: string;
+    field: string;
+    active: boolean;
+    severity: "error" | "warning" | "info";
+    transitions: Record<string, string[]>;
+}, {
+    message: string;
+    type: "state_machine";
+    name: string;
+    field: string;
+    transitions: Record<string, string[]>;
+    active?: boolean | undefined;
+    severity?: "error" | "warning" | "info" | undefined;
+}>;
+/**
+ * 4. Value Format Validation
+ * Regex or specialized formats.
+ */
+export declare const FormatValidationSchema: z.ZodObject<{
+    name: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
+    message: z.ZodString;
+} & {
+    type: z.ZodLiteral<"format">;
+    field: z.ZodString;
+    regex: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<["email", "url", "phone", "json"]>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "format";
+    name: string;
+    field: string;
+    active: boolean;
+    severity: "error" | "warning" | "info";
+    format?: "email" | "url" | "phone" | "json" | undefined;
+    regex?: string | undefined;
+}, {
+    message: string;
+    type: "format";
+    name: string;
+    field: string;
+    active?: boolean | undefined;
+    severity?: "error" | "warning" | "info" | undefined;
+    format?: "email" | "url" | "phone" | "json" | undefined;
+    regex?: string | undefined;
+}>;
+/**
+ * Master Validation Rule Schema
+ */
+export declare const ValidationRuleSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    name: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
+    message: z.ZodString;
+} & {
+    type: z.ZodLiteral<"script">;
+    condition: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "script";
+    name: string;
+    active: boolean;
+    severity: "error" | "warning" | "info";
+    condition: string;
+}, {
+    message: string;
+    type: "script";
+    name: string;
+    condition: string;
+    active?: boolean | undefined;
+    severity?: "error" | "warning" | "info" | undefined;
+}>, z.ZodObject<{
+    name: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
+    message: z.ZodString;
+} & {
+    type: z.ZodLiteral<"unique">;
+    fields: z.ZodArray<z.ZodString, "many">;
+    scope: z.ZodOptional<z.ZodString>;
+    caseSensitive: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "unique";
+    name: string;
+    fields: string[];
+    active: boolean;
+    severity: "error" | "warning" | "info";
+    caseSensitive: boolean;
+    scope?: string | undefined;
+}, {
+    message: string;
+    type: "unique";
+    name: string;
+    fields: string[];
+    active?: boolean | undefined;
+    severity?: "error" | "warning" | "info" | undefined;
+    scope?: string | undefined;
+    caseSensitive?: boolean | undefined;
+}>, z.ZodObject<{
+    name: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
+    message: z.ZodString;
+} & {
+    type: z.ZodLiteral<"state_machine">;
+    field: z.ZodString;
+    transitions: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "state_machine";
+    name: string;
+    field: string;
+    active: boolean;
+    severity: "error" | "warning" | "info";
+    transitions: Record<string, string[]>;
+}, {
+    message: string;
+    type: "state_machine";
+    name: string;
+    field: string;
+    transitions: Record<string, string[]>;
+    active?: boolean | undefined;
+    severity?: "error" | "warning" | "info" | undefined;
+}>, z.ZodObject<{
+    name: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    severity: z.ZodDefault<z.ZodEnum<["error", "warning", "info"]>>;
+    message: z.ZodString;
+} & {
+    type: z.ZodLiteral<"format">;
+    field: z.ZodString;
+    regex: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<["email", "url", "phone", "json"]>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "format";
+    name: string;
+    field: string;
+    active: boolean;
+    severity: "error" | "warning" | "info";
+    format?: "email" | "url" | "phone" | "json" | undefined;
+    regex?: string | undefined;
+}, {
+    message: string;
+    type: "format";
+    name: string;
+    field: string;
+    active?: boolean | undefined;
+    severity?: "error" | "warning" | "info" | undefined;
+    format?: "email" | "url" | "phone" | "json" | undefined;
+    regex?: string | undefined;
+}>]>;
+export type ValidationRule = z.infer<typeof ValidationRuleSchema>;
+export type ScriptValidation = z.infer<typeof ScriptValidationSchema>;
+export type UniquenessValidation = z.infer<typeof UniquenessValidationSchema>;
+export type StateMachineValidation = z.infer<typeof StateMachineValidationSchema>;
+//# sourceMappingURL=validation.zod.d.ts.map

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

@@ -0,0 +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;AAYxB;;;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;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAK/B,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"}

package/dist/data/validation.zod.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationRuleSchema = exports.FormatValidationSchema = exports.StateMachineValidationSchema = exports.UniquenessValidationSchema = exports.ScriptValidationSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Base Validation Rule
+ */
+const BaseValidationSchema = zod_1.z.object({
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Unique rule name'),
+    active: zod_1.z.boolean().default(true),
+    severity: zod_1.z.enum(['error', 'warning', 'info']).default('error'),
+    message: zod_1.z.string().describe('Error message to display'),
+});
+/**
+ * 1. Script/Expression Validation
+ * Generic formula-based validation.
+ */
+exports.ScriptValidationSchema = BaseValidationSchema.extend({
+    type: zod_1.z.literal('script'),
+    condition: zod_1.z.string().describe('Formula expression. If TRUE, validation fails. (e.g. amount < 0)'),
+});
+/**
+ * 2. Uniqueness Validation
+ * specialized optimized check for unique constraints.
+ */
+exports.UniquenessValidationSchema = BaseValidationSchema.extend({
+    type: zod_1.z.literal('unique'),
+    fields: zod_1.z.array(zod_1.z.string()).describe('Fields that must be combined unique'),
+    scope: zod_1.z.string().optional().describe('Formula condition for scope (e.g. active = true)'),
+    caseSensitive: zod_1.z.boolean().default(true),
+});
+/**
+ * 3. State Machine Validation
+ * State transition logic.
+ */
+exports.StateMachineValidationSchema = BaseValidationSchema.extend({
+    type: zod_1.z.literal('state_machine'),
+    field: zod_1.z.string().describe('State field (e.g. status)'),
+    transitions: zod_1.z.record(zod_1.z.array(zod_1.z.string())).describe('Map of { OldState: [AllowedNewStates] }'),
+});
+/**
+ * 4. Value Format Validation
+ * Regex or specialized formats.
+ */
+exports.FormatValidationSchema = BaseValidationSchema.extend({
+    type: zod_1.z.literal('format'),
+    field: zod_1.z.string(),
+    regex: zod_1.z.string().optional(),
+    format: zod_1.z.enum(['email', 'url', 'phone', 'json']).optional(),
+});
+/**
+ * Master Validation Rule Schema
+ */
+exports.ValidationRuleSchema = zod_1.z.discriminatedUnion('type', [
+    exports.ScriptValidationSchema,
+    exports.UniquenessValidationSchema,
+    exports.StateMachineValidationSchema,
+    exports.FormatValidationSchema
+]);

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

@@ -0,0 +1,195 @@
+import { z } from 'zod';
+/**
+ * Trigger events for workflow automation
+ */
+export declare const WorkflowTriggerType: z.ZodEnum<["on_create", "on_update", "on_create_or_update", "on_delete", "schedule"]>;
+/**
+ * Schema for Workflow Field Update Action
+ */
+export declare const FieldUpdateActionSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"field_update">;
+    field: z.ZodString;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    type: "field_update";
+    name: string;
+    field: string;
+    value?: any;
+}, {
+    type: "field_update";
+    name: string;
+    field: string;
+    value?: any;
+}>;
+/**
+ * Schema for Workflow Email Alert Action
+ */
+export declare const EmailAlertActionSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"email_alert">;
+    template: z.ZodString;
+    recipients: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "email_alert";
+    name: string;
+    template: string;
+    recipients: string[];
+}, {
+    type: "email_alert";
+    name: string;
+    template: string;
+    recipients: string[];
+}>;
+/**
+ * Generic Workflow Action Wrapper
+ */
+export declare const WorkflowActionSchema: z.ZodUnion<[z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"field_update">;
+    field: z.ZodString;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    type: "field_update";
+    name: string;
+    field: string;
+    value?: any;
+}, {
+    type: "field_update";
+    name: string;
+    field: string;
+    value?: any;
+}>, z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"email_alert">;
+    template: z.ZodString;
+    recipients: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "email_alert";
+    name: string;
+    template: string;
+    recipients: string[];
+}, {
+    type: "email_alert";
+    name: string;
+    template: string;
+    recipients: string[];
+}>, z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    options: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    name: string;
+    options?: any;
+}, {
+    type: string;
+    name: string;
+    options?: any;
+}>]>;
+/**
+ * Schema for Workflow Rules (Automation)
+ */
+export declare const WorkflowRuleSchema: z.ZodObject<{
+    /** Machine name */
+    name: z.ZodString;
+    /** Target Object */
+    objectName: z.ZodString;
+    /** When to evaluate the rule */
+    triggerType: z.ZodEnum<["on_create", "on_update", "on_create_or_update", "on_delete", "schedule"]>;
+    /**
+     * Condition to start the workflow.
+     * If empty, runs on every trigger event.
+     */
+    criteria: z.ZodOptional<z.ZodString>;
+    /** Actions to execute immediately */
+    actions: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodLiteral<"field_update">;
+        field: z.ZodString;
+        value: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        type: "field_update";
+        name: string;
+        field: string;
+        value?: any;
+    }, {
+        type: "field_update";
+        name: string;
+        field: string;
+        value?: any;
+    }>, z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodLiteral<"email_alert">;
+        template: z.ZodString;
+        recipients: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "email_alert";
+        name: string;
+        template: string;
+        recipients: string[];
+    }, {
+        type: "email_alert";
+        name: string;
+        template: string;
+        recipients: string[];
+    }>, z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        options: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        name: string;
+        options?: any;
+    }, {
+        type: string;
+        name: string;
+        options?: any;
+    }>]>, "many">>;
+    /** Active status */
+    active: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    active: boolean;
+    objectName: string;
+    triggerType: "on_create" | "on_update" | "on_create_or_update" | "on_delete" | "schedule";
+    criteria?: string | undefined;
+    actions?: ({
+        type: "field_update";
+        name: string;
+        field: string;
+        value?: any;
+    } | {
+        type: "email_alert";
+        name: string;
+        template: string;
+        recipients: string[];
+    } | {
+        type: string;
+        name: string;
+        options?: any;
+    })[] | undefined;
+}, {
+    name: string;
+    objectName: string;
+    triggerType: "on_create" | "on_update" | "on_create_or_update" | "on_delete" | "schedule";
+    active?: boolean | undefined;
+    criteria?: string | undefined;
+    actions?: ({
+        type: "field_update";
+        name: string;
+        field: string;
+        value?: any;
+    } | {
+        type: "email_alert";
+        name: string;
+        template: string;
+        recipients: string[];
+    } | {
+        type: string;
+        name: string;
+        options?: any;
+    })[] | undefined;
+}>;
+export type WorkflowRule = z.infer<typeof WorkflowRuleSchema>;
+//# sourceMappingURL=workflow.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.zod.d.ts","sourceRoot":"","sources":["../../src/data/workflow.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,mBAAmB,uFAM9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;EAKlC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;EAKjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQ/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B,mBAAmB;;IAGnB,oBAAoB;;IAGpB,gCAAgC;;IAGhC;;;OAGG;;IAGH,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGrC,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEpB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/data/workflow.zod.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowRuleSchema = exports.WorkflowActionSchema = exports.EmailAlertActionSchema = exports.FieldUpdateActionSchema = exports.WorkflowTriggerType = void 0;
+const zod_1 = require("zod");
+/**
+ * Trigger events for workflow automation
+ */
+exports.WorkflowTriggerType = zod_1.z.enum([
+    'on_create', // When record is created
+    'on_update', // When record is updated
+    'on_create_or_update', // Both
+    'on_delete', // When record is deleted
+    'schedule' // Time-based (cron)
+]);
+/**
+ * Schema for Workflow Field Update Action
+ */
+exports.FieldUpdateActionSchema = zod_1.z.object({
+    name: zod_1.z.string().describe('Action name'),
+    type: zod_1.z.literal('field_update'),
+    field: zod_1.z.string().describe('Field to update'),
+    value: zod_1.z.any().describe('Value or Formula to set'),
+});
+/**
+ * Schema for Workflow Email Alert Action
+ */
+exports.EmailAlertActionSchema = zod_1.z.object({
+    name: zod_1.z.string().describe('Action name'),
+    type: zod_1.z.literal('email_alert'),
+    template: zod_1.z.string().describe('Email template ID/DevName'),
+    recipients: zod_1.z.array(zod_1.z.string()).describe('List of recipient emails or user IDs'),
+});
+/**
+ * Generic Workflow Action Wrapper
+ */
+exports.WorkflowActionSchema = zod_1.z.union([
+    exports.FieldUpdateActionSchema,
+    exports.EmailAlertActionSchema,
+    zod_1.z.object({
+        name: zod_1.z.string(),
+        type: zod_1.z.string(),
+        options: zod_1.z.any()
+    })
+]);
+/**
+ * Schema for Workflow Rules (Automation)
+ */
+exports.WorkflowRuleSchema = zod_1.z.object({
+    /** Machine name */
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Unique workflow name'),
+    /** Target Object */
+    objectName: zod_1.z.string().describe('Target Object'),
+    /** When to evaluate the rule */
+    triggerType: exports.WorkflowTriggerType.describe('When to evaluate'),
+    /**
+     * Condition to start the workflow.
+     * If empty, runs on every trigger event.
+     */
+    criteria: zod_1.z.string().optional().describe('Formula condition. If TRUE, actions execute.'),
+    /** Actions to execute immediately */
+    actions: zod_1.z.array(exports.WorkflowActionSchema).optional().describe('Immediate actions'),
+    /** Active status */
+    active: zod_1.z.boolean().default(true).describe('Whether this workflow is active'),
+});

package/dist/index.d.ts

@@ -1,10 +1,38 @@
 /**
- * ObjectStack Specification
+ * @objectstack/spec
  *
- * This module provides the core type definitions and interfaces for the ObjectStack ecosystem.
- * It defines the contract between backend (ObjectQL) parsers and frontend (ObjectUI) renderers.
+ * ObjectStack Protocol & Specification
  *
- * @packageDocumentation
+ * This package contains the core interfaces, schemas, and conventions for the ObjectStack ecosystem.
+ * All types and schemas are centralized here.
  */
-export * from './types';
+export * from './data/field.zod';
+export * from './data/object.zod';
+export * from './data/validation.zod';
+export * from './data/permission.zod';
+export * from './data/sharing.zod';
+export * from './data/workflow.zod';
+export * from './data/flow.zod';
+export * from './data/dataset.zod';
+export * from './data/query.zod';
+export * from './data/mapping.zod';
+export * from './ai/agent.zod';
+export * from './ui/app.zod';
+export * from './ui/view.zod';
+export * from './ui/dashboard.zod';
+export * from './ui/report.zod';
+export * from './ui/action.zod';
+export * from './ui/page.zod';
+export * from './system/manifest.zod';
+export * from './system/datasource.zod';
+export * from './system/api.zod';
+export * from './system/identity.zod';
+export * from './system/policy.zod';
+export * from './system/role.zod';
+export * from './system/territory.zod';
+export * from './system/license.zod';
+export * from './system/webhook.zod';
+export * from './system/translation.zod';
+export * from './system/constants';
+export * from './system/types';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,gBAAgB,CAAC;AAG/B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAG9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -1,9 +1,57 @@
+"use strict";
 /**
- * ObjectStack Specification
+ * @objectstack/spec
  *
- * This module provides the core type definitions and interfaces for the ObjectStack ecosystem.
- * It defines the contract between backend (ObjectQL) parsers and frontend (ObjectUI) renderers.
+ * ObjectStack Protocol & Specification
  *
- * @packageDocumentation
+ * This package contains the core interfaces, schemas, and conventions for the ObjectStack ecosystem.
+ * All types and schemas are centralized here.
  */
-export * from './types';
+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 });
+// Data Protocol (Schema, Validation, Logic)
+__exportStar(require("./data/field.zod"), exports);
+__exportStar(require("./data/object.zod"), exports);
+__exportStar(require("./data/validation.zod"), exports);
+__exportStar(require("./data/permission.zod"), exports);
+__exportStar(require("./data/sharing.zod"), exports);
+__exportStar(require("./data/workflow.zod"), exports);
+__exportStar(require("./data/flow.zod"), exports);
+__exportStar(require("./data/dataset.zod"), exports);
+__exportStar(require("./data/query.zod"), exports);
+__exportStar(require("./data/mapping.zod"), exports);
+// AI Protocol (Agent, RAG)
+__exportStar(require("./ai/agent.zod"), exports);
+// UI Protocol (Layout, Navigation, Interaction)
+__exportStar(require("./ui/app.zod"), exports);
+__exportStar(require("./ui/view.zod"), exports);
+__exportStar(require("./ui/dashboard.zod"), exports);
+__exportStar(require("./ui/report.zod"), exports);
+__exportStar(require("./ui/action.zod"), exports);
+__exportStar(require("./ui/page.zod"), exports);
+// System Protocol (Manifest, Runtime, Constants)
+__exportStar(require("./system/manifest.zod"), exports);
+__exportStar(require("./system/datasource.zod"), exports);
+__exportStar(require("./system/api.zod"), exports);
+__exportStar(require("./system/identity.zod"), exports);
+__exportStar(require("./system/policy.zod"), exports);
+__exportStar(require("./system/role.zod"), exports);
+__exportStar(require("./system/territory.zod"), exports);
+__exportStar(require("./system/license.zod"), exports);
+__exportStar(require("./system/webhook.zod"), exports);
+__exportStar(require("./system/translation.zod"), exports);
+__exportStar(require("./system/constants"), exports);
+__exportStar(require("./system/types"), exports);