@objectstack/spec 0.1.1 → 0.1.2

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

@@ -117,120 +117,160 @@ export declare const FormatValidationSchema: z.ZodObject<{
     type: "format";
     name: string;
     field: string;
+    format?: "email" | "url" | "phone" | "json" | undefined;
     active?: boolean | undefined;
     severity?: "error" | "warning" | "info" | undefined;
-    format?: "email" | "url" | "phone" | "json" | undefined;
     regex?: string | undefined;
 }>;
 /**
- * Master Validation Rule Schema
+ * 5. Cross-Field Validation
+ * Validates relationships between multiple fields.
  */
-export declare const ValidationRuleSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+export declare const CrossFieldValidationSchema: 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">;
+    type: z.ZodLiteral<"cross_field">;
     condition: z.ZodString;
+    fields: z.ZodArray<z.ZodString, "many">;
 }, "strip", z.ZodTypeAny, {
     message: string;
-    type: "script";
+    type: "cross_field";
     name: string;
+    fields: string[];
     active: boolean;
     severity: "error" | "warning" | "info";
     condition: string;
 }, {
     message: string;
-    type: "script";
+    type: "cross_field";
     name: string;
+    fields: string[];
     condition: string;
     active?: boolean | undefined;
     severity?: "error" | "warning" | "info" | undefined;
-}>, z.ZodObject<{
+}>;
+/**
+ * 6. Async Validation
+ * Remote validation via API call or database query.
+ */
+export declare const AsyncValidationSchema: 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>;
+    type: z.ZodLiteral<"async">;
+    field: z.ZodString;
+    validatorUrl: z.ZodOptional<z.ZodString>;
+    validatorFunction: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    debounce: z.ZodOptional<z.ZodNumber>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, "strip", z.ZodTypeAny, {
     message: string;
-    type: "unique";
+    type: "async";
     name: string;
-    fields: string[];
+    field: string;
     active: boolean;
     severity: "error" | "warning" | "info";
-    caseSensitive: boolean;
-    scope?: string | undefined;
+    timeout: number;
+    params?: Record<string, any> | undefined;
+    validatorUrl?: string | undefined;
+    validatorFunction?: string | undefined;
+    debounce?: number | undefined;
 }, {
     message: string;
-    type: "unique";
+    type: "async";
     name: string;
-    fields: string[];
+    field: string;
+    params?: Record<string, any> | undefined;
     active?: boolean | undefined;
     severity?: "error" | "warning" | "info" | undefined;
-    scope?: string | undefined;
-    caseSensitive?: boolean | undefined;
-}>, z.ZodObject<{
+    validatorUrl?: string | undefined;
+    validatorFunction?: string | undefined;
+    timeout?: number | undefined;
+    debounce?: number | undefined;
+}>;
+/**
+ * 7. Custom Validator Function
+ * User-defined validation logic with code reference.
+ */
+export declare const CustomValidatorSchema: 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">>;
+    type: z.ZodLiteral<"custom">;
+    field: z.ZodOptional<z.ZodString>;
+    validatorFunction: z.ZodString;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, "strip", z.ZodTypeAny, {
     message: string;
-    type: "state_machine";
+    type: "custom";
     name: string;
-    field: string;
     active: boolean;
     severity: "error" | "warning" | "info";
-    transitions: Record<string, string[]>;
+    validatorFunction: string;
+    params?: Record<string, any> | undefined;
+    field?: string | undefined;
 }, {
     message: string;
-    type: "state_machine";
+    type: "custom";
     name: string;
-    field: string;
-    transitions: Record<string, string[]>;
+    validatorFunction: string;
+    params?: Record<string, any> | undefined;
+    field?: string | undefined;
     active?: boolean | undefined;
     severity?: "error" | "warning" | "info" | undefined;
-}>, z.ZodObject<{
+}>;
+/**
+ * Master Validation Rule Schema (forward declared for circular reference)
+ */
+export declare const ValidationRuleSchema: z.ZodType<any>;
+/**
+ * 8. Conditional Validation
+ * Validation that only applies when a condition is met.
+ */
+export declare const ConditionalValidationSchema: 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"]>>;
+    type: z.ZodLiteral<"conditional">;
+    when: z.ZodString;
+    then: z.ZodType<any, z.ZodTypeDef, any>;
+    otherwise: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
 }, "strip", z.ZodTypeAny, {
     message: string;
-    type: "format";
+    type: "conditional";
     name: string;
-    field: string;
     active: boolean;
     severity: "error" | "warning" | "info";
-    format?: "email" | "url" | "phone" | "json" | undefined;
-    regex?: string | undefined;
+    when: string;
+    then?: any;
+    otherwise?: any;
 }, {
     message: string;
-    type: "format";
+    type: "conditional";
     name: string;
-    field: string;
+    when: string;
     active?: boolean | undefined;
     severity?: "error" | "warning" | "info" | undefined;
-    format?: "email" | "url" | "phone" | "json" | undefined;
-    regex?: string | undefined;
-}>]>;
+    then?: any;
+    otherwise?: any;
+}>;
 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>;
+export type FormatValidation = z.infer<typeof FormatValidationSchema>;
+export type CrossFieldValidation = z.infer<typeof CrossFieldValidationSchema>;
+export type AsyncValidation = z.infer<typeof AsyncValidationSchema>;
+export type CustomValidation = z.infer<typeof CustomValidatorSchema>;
+export type ConditionalValidation = z.infer<typeof ConditionalValidationSchema>;
 //# sourceMappingURL=validation.zod.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"validation.zod.d.ts","sourceRoot":"","sources":["../../src/data/validation.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;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"}
+{"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;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;EAIrC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQhC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAW/C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtC,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACrE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/data/validation.zod.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationRuleSchema = exports.FormatValidationSchema = exports.StateMachineValidationSchema = exports.UniquenessValidationSchema = exports.ScriptValidationSchema = void 0;
+exports.ConditionalValidationSchema = exports.ValidationRuleSchema = exports.CustomValidatorSchema = exports.AsyncValidationSchema = exports.CrossFieldValidationSchema = exports.FormatValidationSchema = exports.StateMachineValidationSchema = exports.UniquenessValidationSchema = exports.ScriptValidationSchema = void 0;
 const zod_1 = require("zod");
 /**
  * Base Validation Rule
@@ -49,11 +49,57 @@ exports.FormatValidationSchema = BaseValidationSchema.extend({
     format: zod_1.z.enum(['email', 'url', 'phone', 'json']).optional(),
 });
 /**
- * Master Validation Rule Schema
+ * 5. Cross-Field Validation
+ * Validates relationships between multiple fields.
  */
-exports.ValidationRuleSchema = zod_1.z.discriminatedUnion('type', [
+exports.CrossFieldValidationSchema = BaseValidationSchema.extend({
+    type: zod_1.z.literal('cross_field'),
+    condition: zod_1.z.string().describe('Formula expression comparing fields (e.g. "end_date > start_date")'),
+    fields: zod_1.z.array(zod_1.z.string()).describe('Fields involved in the validation'),
+});
+/**
+ * 6. Async Validation
+ * Remote validation via API call or database query.
+ */
+exports.AsyncValidationSchema = BaseValidationSchema.extend({
+    type: zod_1.z.literal('async'),
+    field: zod_1.z.string().describe('Field to validate'),
+    validatorUrl: zod_1.z.string().optional().describe('External API endpoint for validation'),
+    validatorFunction: zod_1.z.string().optional().describe('Reference to custom validator function'),
+    timeout: zod_1.z.number().optional().default(5000).describe('Timeout in milliseconds'),
+    debounce: zod_1.z.number().optional().describe('Debounce delay in milliseconds'),
+    params: zod_1.z.record(zod_1.z.any()).optional().describe('Additional parameters to pass to validator'),
+});
+/**
+ * 7. Custom Validator Function
+ * User-defined validation logic with code reference.
+ */
+exports.CustomValidatorSchema = BaseValidationSchema.extend({
+    type: zod_1.z.literal('custom'),
+    field: zod_1.z.string().optional().describe('Field to validate (optional for record-level validation)'),
+    validatorFunction: zod_1.z.string().describe('Function name or reference to custom validator'),
+    params: zod_1.z.record(zod_1.z.any()).optional().describe('Additional parameters for the validator'),
+});
+/**
+ * Master Validation Rule Schema (forward declared for circular reference)
+ */
+exports.ValidationRuleSchema = zod_1.z.lazy(() => zod_1.z.discriminatedUnion('type', [
     exports.ScriptValidationSchema,
     exports.UniquenessValidationSchema,
     exports.StateMachineValidationSchema,
-    exports.FormatValidationSchema
-]);
+    exports.FormatValidationSchema,
+    exports.CrossFieldValidationSchema,
+    exports.AsyncValidationSchema,
+    exports.CustomValidatorSchema,
+    exports.ConditionalValidationSchema,
+]));
+/**
+ * 8. Conditional Validation
+ * Validation that only applies when a condition is met.
+ */
+exports.ConditionalValidationSchema = BaseValidationSchema.extend({
+    type: zod_1.z.literal('conditional'),
+    when: zod_1.z.string().describe('Condition formula (e.g. "type = \'enterprise\'")'),
+    then: exports.ValidationRuleSchema.describe('Validation rule to apply when condition is true'),
+    otherwise: exports.ValidationRuleSchema.optional().describe('Validation rule to apply when condition is false'),
+});

package/dist/index.d.ts

@@ -16,6 +16,8 @@ export * from './data/flow.zod';
 export * from './data/dataset.zod';
 export * from './data/query.zod';
 export * from './data/mapping.zod';
+export * from './data/trigger.zod';
+export * from './api/contract.zod';
 export * from './ai/agent.zod';
 export * from './ui/app.zod';
 export * from './ui/view.zod';
@@ -23,6 +25,8 @@ export * from './ui/dashboard.zod';
 export * from './ui/report.zod';
 export * from './ui/action.zod';
 export * from './ui/page.zod';
+export * from './ui/widget.zod';
+export * from './ui/theme.zod';
 export * from './system/manifest.zod';
 export * from './system/datasource.zod';
 export * from './system/api.zod';
@@ -33,6 +37,10 @@ export * from './system/territory.zod';
 export * from './system/license.zod';
 export * from './system/webhook.zod';
 export * from './system/translation.zod';
+export * from './system/driver.zod';
 export * from './system/constants';
 export * from './system/types';
+export * from './system/discovery.zod';
+export * from './system/plugin.zod';
+export * from './system/driver.zod';
 //# 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;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"}
+{"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;AACnC,cAAc,oBAAoB,CAAC;AAGnC,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;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAG/B,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,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -33,6 +33,9 @@ __exportStar(require("./data/flow.zod"), exports);
 __exportStar(require("./data/dataset.zod"), exports);
 __exportStar(require("./data/query.zod"), exports);
 __exportStar(require("./data/mapping.zod"), exports);
+__exportStar(require("./data/trigger.zod"), exports);
+// API Protocol (Envelopes, Contracts)
+__exportStar(require("./api/contract.zod"), exports);
 // AI Protocol (Agent, RAG)
 __exportStar(require("./ai/agent.zod"), exports);
 // UI Protocol (Layout, Navigation, Interaction)
@@ -42,6 +45,8 @@ __exportStar(require("./ui/dashboard.zod"), exports);
 __exportStar(require("./ui/report.zod"), exports);
 __exportStar(require("./ui/action.zod"), exports);
 __exportStar(require("./ui/page.zod"), exports);
+__exportStar(require("./ui/widget.zod"), exports);
+__exportStar(require("./ui/theme.zod"), exports);
 // System Protocol (Manifest, Runtime, Constants)
 __exportStar(require("./system/manifest.zod"), exports);
 __exportStar(require("./system/datasource.zod"), exports);
@@ -53,5 +58,9 @@ __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/driver.zod"), exports); // Export Driver Protocol
 __exportStar(require("./system/constants"), exports);
 __exportStar(require("./system/types"), exports);
+__exportStar(require("./system/discovery.zod"), exports);
+__exportStar(require("./system/plugin.zod"), exports);
+__exportStar(require("./system/driver.zod"), exports);

package/dist/system/api.zod.d.ts

@@ -57,10 +57,10 @@ export declare const ApiEndpointSchema: z.ZodObject<{
         operation: z.ZodOptional<z.ZodEnum<["find", "get", "create", "update", "delete"]>>;
     }, "strip", z.ZodTypeAny, {
         object?: string | undefined;
-        operation?: "find" | "update" | "get" | "create" | "delete" | undefined;
+        operation?: "find" | "get" | "create" | "update" | "delete" | undefined;
     }, {
         object?: string | undefined;
-        operation?: "find" | "update" | "get" | "create" | "delete" | undefined;
+        operation?: "find" | "get" | "create" | "update" | "delete" | undefined;
     }>>;
     /** Data Transformation */
     inputMapping: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -116,7 +116,7 @@ export declare const ApiEndpointSchema: z.ZodObject<{
     description?: string | undefined;
     objectParams?: {
         object?: string | undefined;
-        operation?: "find" | "update" | "get" | "create" | "delete" | undefined;
+        operation?: "find" | "get" | "create" | "update" | "delete" | undefined;
     } | undefined;
     inputMapping?: {
         source: string;
@@ -144,7 +144,7 @@ export declare const ApiEndpointSchema: z.ZodObject<{
     description?: string | undefined;
     objectParams?: {
         object?: string | undefined;
-        operation?: "find" | "update" | "get" | "create" | "delete" | undefined;
+        operation?: "find" | "get" | "create" | "update" | "delete" | undefined;
     } | undefined;
     inputMapping?: {
         source: string;
@@ -164,5 +164,131 @@ export declare const ApiEndpointSchema: z.ZodObject<{
     } | undefined;
     cacheTtl?: number | undefined;
 }>;
+export declare const ApiEndpoint: z.ZodObject<{
+    /** Identity */
+    name: z.ZodString;
+    path: z.ZodString;
+    method: z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>;
+    /** Documentation */
+    summary: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    /** Execution Logic */
+    type: z.ZodEnum<["flow", "script", "object_operation", "proxy"]>;
+    target: z.ZodString;
+    /** Logic Config */
+    objectParams: z.ZodOptional<z.ZodObject<{
+        object: z.ZodOptional<z.ZodString>;
+        operation: z.ZodOptional<z.ZodEnum<["find", "get", "create", "update", "delete"]>>;
+    }, "strip", z.ZodTypeAny, {
+        object?: string | undefined;
+        operation?: "find" | "get" | "create" | "update" | "delete" | undefined;
+    }, {
+        object?: string | undefined;
+        operation?: "find" | "get" | "create" | "update" | "delete" | undefined;
+    }>>;
+    /** Data Transformation */
+    inputMapping: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+        transform: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }, {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }>, "many">>;
+    outputMapping: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+        transform: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }, {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }>, "many">>;
+    /** Policies */
+    authRequired: z.ZodDefault<z.ZodBoolean>;
+    rateLimit: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        windowMs: z.ZodDefault<z.ZodNumber>;
+        maxRequests: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        windowMs: number;
+        maxRequests: number;
+    }, {
+        enabled?: boolean | undefined;
+        windowMs?: number | undefined;
+        maxRequests?: number | undefined;
+    }>>;
+    cacheTtl: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "script" | "flow" | "object_operation" | "proxy";
+    name: string;
+    target: string;
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    authRequired: boolean;
+    summary?: string | undefined;
+    description?: string | undefined;
+    objectParams?: {
+        object?: string | undefined;
+        operation?: "find" | "get" | "create" | "update" | "delete" | undefined;
+    } | undefined;
+    inputMapping?: {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }[] | undefined;
+    outputMapping?: {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }[] | undefined;
+    rateLimit?: {
+        enabled: boolean;
+        windowMs: number;
+        maxRequests: number;
+    } | undefined;
+    cacheTtl?: number | undefined;
+}, {
+    path: string;
+    type: "script" | "flow" | "object_operation" | "proxy";
+    name: string;
+    target: string;
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    summary?: string | undefined;
+    description?: string | undefined;
+    objectParams?: {
+        object?: string | undefined;
+        operation?: "find" | "get" | "create" | "update" | "delete" | undefined;
+    } | undefined;
+    inputMapping?: {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }[] | undefined;
+    outputMapping?: {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }[] | undefined;
+    authRequired?: boolean | undefined;
+    rateLimit?: {
+        enabled?: boolean | undefined;
+        windowMs?: number | undefined;
+        maxRequests?: number | undefined;
+    } | undefined;
+    cacheTtl?: number | undefined;
+}> & {
+    create: <T extends z.input<typeof ApiEndpointSchema>>(config: T) => T;
+};
 export type ApiEndpoint = z.infer<typeof ApiEndpointSchema>;
 //# sourceMappingURL=api.zod.d.ts.map

package/dist/system/api.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.zod.d.ts","sourceRoot":"","sources":["../../src/system/api.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,UAAU,sDAAoD,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;EAI1B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAI3B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB;IAC5B,eAAe;;;;IAKf,oBAAoB;;;IAIpB,sBAAsB;;;IAItB,mBAAmB;;;;;;;;;;;IAMnB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;IAI1B,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIf,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"api.zod.d.ts","sourceRoot":"","sources":["../../src/system/api.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,UAAU,sDAAoD,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;EAI1B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAI3B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB;IAC5B,eAAe;;;;IAKf,oBAAoB;;;IAIpB,sBAAsB;;;IAItB,mBAAmB;;;;;;;;;;;IAMnB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;IAI1B,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIf,CAAC;AAEH,eAAO,MAAM,WAAW;IA7BtB,eAAe;;;;IAKf,oBAAoB;;;IAIpB,sBAAsB;;;IAItB,mBAAmB;;;;;;;;;;;IAMnB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;IAI1B,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAON,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,UAAU,CAAC;CAC/D,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/system/api.zod.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiEndpointSchema = exports.ApiMappingSchema = exports.RateLimitSchema = exports.HttpMethod = void 0;
+exports.ApiEndpoint = exports.ApiEndpointSchema = exports.ApiMappingSchema = exports.RateLimitSchema = exports.HttpMethod = void 0;
 const zod_1 = require("zod");
 /**
  * HTTP Method Enum
@@ -51,3 +51,6 @@ exports.ApiEndpointSchema = zod_1.z.object({
     rateLimit: exports.RateLimitSchema.optional().describe('Rate limiting policy'),
     cacheTtl: zod_1.z.number().optional().describe('Response cache TTL in seconds'),
 });
+exports.ApiEndpoint = Object.assign(exports.ApiEndpointSchema, {
+    create: (config) => config,
+});

package/dist/system/datasource.zod.d.ts

@@ -1,9 +1,92 @@
 import { z } from 'zod';
 /**
- * Driver Type Enum
- * Defines the underlying technology of the datasource.
+ * Driver Type Enum (Built-in)
+ * Standard drivers supported by the core platform.
+ * Plugins can register additional drivers using different identifiers.
  */
-export declare const DriverType: z.ZodEnum<["postgres", "mysql", "sqlserver", "oracle", "sqlite", "mongo", "redis", "excel", "csv", "airtable", "rest_api", "graphql", "odata", "salesforce", "sap", "workday"]>;
+export declare const BuiltInDrivers: readonly ["postgres", "mysql", "sqlserver", "oracle", "sqlite", "mongo", "redis", "excel", "csv", "airtable", "rest_api", "graphql", "odata", "salesforce", "sap", "workday"];
+/**
+ * Driver Identifier
+ * Can be a built-in driver or a plugin-contributed driver (e.g., "com.vendor.snowflake").
+ */
+export declare const DriverType: z.ZodString;
+/**
+ * Driver Definition Schema
+ * Metadata describing a Database Driver.
+ * Plugins use this to register new connectivity options.
+ */
+export declare const DriverDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    /**
+     * Configuration Schema (JSON Schema)
+     * Describes the structure of the `config` object needed for this driver.
+     * Used by the UI to generate the connection form.
+     */
+    configSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+    /**
+     * Default Capabilities
+     * What this driver supports out-of-the-box.
+     */
+    capabilities: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+        /** Can execute SQL-like joins natively? */
+        joins: z.ZodDefault<z.ZodBoolean>;
+        /** Can handle ACID transactions? */
+        transactions: z.ZodDefault<z.ZodBoolean>;
+        /** Can perform full-text search? */
+        fullTextSearch: z.ZodDefault<z.ZodBoolean>;
+        /** Can perform aggregation (group by, sum, avg)? */
+        aggregation: z.ZodDefault<z.ZodBoolean>;
+        /** Is scheme-less (needs schema inference)? */
+        dynamicSchema: z.ZodDefault<z.ZodBoolean>;
+        /** Is read-only? */
+        readOnly: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        joins: boolean;
+        transactions: boolean;
+        fullTextSearch: boolean;
+        aggregation: boolean;
+        dynamicSchema: boolean;
+        readOnly: boolean;
+    }, {
+        joins?: boolean | undefined;
+        transactions?: boolean | undefined;
+        fullTextSearch?: boolean | undefined;
+        aggregation?: boolean | undefined;
+        dynamicSchema?: boolean | undefined;
+        readOnly?: boolean | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    id: string;
+    configSchema: Record<string, any>;
+    description?: string | undefined;
+    icon?: string | undefined;
+    capabilities?: {
+        joins: boolean;
+        transactions: boolean;
+        fullTextSearch: boolean;
+        aggregation: boolean;
+        dynamicSchema: boolean;
+        readOnly: boolean;
+    } | undefined;
+}, {
+    label: string;
+    id: string;
+    configSchema: Record<string, any>;
+    description?: string | undefined;
+    icon?: string | undefined;
+    capabilities?: {
+        joins?: boolean | undefined;
+        transactions?: boolean | undefined;
+        fullTextSearch?: boolean | undefined;
+        aggregation?: boolean | undefined;
+        dynamicSchema?: boolean | undefined;
+        readOnly?: boolean | undefined;
+    } | undefined;
+}>;
 /**
  * Datasource Capabilities Schema
  * Declares what this datasource naturally supports.
@@ -48,7 +131,7 @@ export declare const DatasourceSchema: z.ZodObject<{
     /** Human Label */
     label: z.ZodOptional<z.ZodString>;
     /** Driver */
-    driver: z.ZodEnum<["postgres", "mysql", "sqlserver", "oracle", "sqlite", "mongo", "redis", "excel", "csv", "airtable", "rest_api", "graphql", "odata", "salesforce", "sap", "workday"]>;
+    driver: z.ZodString;
     /**
      * Connection Configuration
      * Specific to the driver (e.g., host, port, user, password, bucket, etc.)
@@ -95,7 +178,7 @@ export declare const DatasourceSchema: z.ZodObject<{
     name: string;
     active: boolean;
     config: Record<string, any>;
-    driver: "csv" | "postgres" | "mysql" | "sqlserver" | "oracle" | "sqlite" | "mongo" | "redis" | "excel" | "airtable" | "rest_api" | "graphql" | "odata" | "salesforce" | "sap" | "workday";
+    driver: string;
     label?: string | undefined;
     description?: string | undefined;
     capabilities?: {
@@ -109,7 +192,7 @@ export declare const DatasourceSchema: z.ZodObject<{
 }, {
     name: string;
     config: Record<string, any>;
-    driver: "csv" | "postgres" | "mysql" | "sqlserver" | "oracle" | "sqlite" | "mongo" | "redis" | "excel" | "airtable" | "rest_api" | "graphql" | "odata" | "salesforce" | "sap" | "workday";
+    driver: string;
     label?: string | undefined;
     description?: string | undefined;
     active?: boolean | undefined;