@objectstack/spec 0.1.0 → 0.1.2

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

@@ -0,0 +1,276 @@
+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;
+    format?: "email" | "url" | "phone" | "json" | undefined;
+    active?: boolean | undefined;
+    severity?: "error" | "warning" | "info" | undefined;
+    regex?: string | undefined;
+}>;
+/**
+ * 5. Cross-Field Validation
+ * Validates relationships between multiple fields.
+ */
+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<"cross_field">;
+    condition: z.ZodString;
+    fields: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "cross_field";
+    name: string;
+    fields: string[];
+    active: boolean;
+    severity: "error" | "warning" | "info";
+    condition: string;
+}, {
+    message: string;
+    type: "cross_field";
+    name: string;
+    fields: string[];
+    condition: string;
+    active?: boolean | undefined;
+    severity?: "error" | "warning" | "info" | undefined;
+}>;
+/**
+ * 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<"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: "async";
+    name: string;
+    field: string;
+    active: boolean;
+    severity: "error" | "warning" | "info";
+    timeout: number;
+    params?: Record<string, any> | undefined;
+    validatorUrl?: string | undefined;
+    validatorFunction?: string | undefined;
+    debounce?: number | undefined;
+}, {
+    message: string;
+    type: "async";
+    name: string;
+    field: string;
+    params?: Record<string, any> | undefined;
+    active?: boolean | undefined;
+    severity?: "error" | "warning" | "info" | undefined;
+    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<"custom">;
+    field: z.ZodOptional<z.ZodString>;
+    validatorFunction: z.ZodString;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "custom";
+    name: string;
+    active: boolean;
+    severity: "error" | "warning" | "info";
+    validatorFunction: string;
+    params?: Record<string, any> | undefined;
+    field?: string | undefined;
+}, {
+    message: string;
+    type: "custom";
+    name: string;
+    validatorFunction: string;
+    params?: Record<string, any> | undefined;
+    field?: string | undefined;
+    active?: boolean | undefined;
+    severity?: "error" | "warning" | "info" | undefined;
+}>;
+/**
+ * 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<"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: "conditional";
+    name: string;
+    active: boolean;
+    severity: "error" | "warning" | "info";
+    when: string;
+    then?: any;
+    otherwise?: any;
+}, {
+    message: string;
+    type: "conditional";
+    name: string;
+    when: string;
+    active?: boolean | undefined;
+    severity?: "error" | "warning" | "info" | 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

@@ -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;;;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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+ */
+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(),
+});
+/**
+ * 5. Cross-Field Validation
+ * Validates relationships between multiple fields.
+ */
+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.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/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'),
+});