@objectstack/spec 0.1.0 → 0.1.1

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

@@ -0,0 +1,170 @@
+import { z } from 'zod';
+/**
+ * Field Type Enum
+ */
+export declare const FieldType: z.ZodEnum<["text", "textarea", "email", "url", "phone", "password", "markdown", "html", "number", "currency", "percent", "date", "datetime", "time", "boolean", "select", "multiselect", "lookup", "master_detail", "image", "file", "avatar", "formula", "summary", "autonumber"]>;
+export type FieldType = z.infer<typeof FieldType>;
+/**
+ * Select Option Schema
+ */
+export declare const SelectOptionSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodString;
+    color: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    label: string;
+    color?: string | undefined;
+    default?: boolean | undefined;
+}, {
+    value: string;
+    label: string;
+    color?: string | undefined;
+    default?: boolean | undefined;
+}>;
+/**
+ * Field Schema - Best Practice Enterprise Pattern
+ */
+export declare const FieldSchema: z.ZodObject<{
+    /** Identity */
+    name: z.ZodString;
+    label: z.ZodString;
+    type: z.ZodEnum<["text", "textarea", "email", "url", "phone", "password", "markdown", "html", "number", "currency", "percent", "date", "datetime", "time", "boolean", "select", "multiselect", "lookup", "master_detail", "image", "file", "avatar", "formula", "summary", "autonumber"]>;
+    description: z.ZodOptional<z.ZodString>;
+    /** Database Constraints */
+    required: z.ZodDefault<z.ZodBoolean>;
+    multiple: z.ZodDefault<z.ZodBoolean>;
+    unique: z.ZodDefault<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    /** Text/String Constraints */
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    /** Number Constraints */
+    precision: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodNumber>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    /** Selection Options */
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        label: string;
+        color?: string | undefined;
+        default?: boolean | undefined;
+    }, {
+        value: string;
+        label: string;
+        color?: string | undefined;
+        default?: boolean | undefined;
+    }>, "many">>;
+    /** Relationship Config */
+    reference: z.ZodOptional<z.ZodString>;
+    referenceFilters: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    writeRequiresMasterRead: z.ZodOptional<z.ZodBoolean>;
+    deleteBehavior: z.ZodDefault<z.ZodOptional<z.ZodEnum<["set_null", "cascade", "restrict"]>>>;
+    /** Calculation */
+    expression: z.ZodOptional<z.ZodString>;
+    formula: z.ZodOptional<z.ZodString>;
+    summaryOperations: z.ZodOptional<z.ZodObject<{
+        object: z.ZodString;
+        field: z.ZodString;
+        function: z.ZodEnum<["count", "sum", "min", "max", "avg"]>;
+    }, "strip", z.ZodTypeAny, {
+        object: string;
+        function: "min" | "max" | "count" | "sum" | "avg";
+        field: string;
+    }, {
+        object: string;
+        function: "min" | "max" | "count" | "sum" | "avg";
+        field: string;
+    }>>;
+    /** Security & Visibility */
+    hidden: z.ZodDefault<z.ZodBoolean>;
+    readonly: z.ZodDefault<z.ZodBoolean>;
+    encryption: z.ZodDefault<z.ZodBoolean>;
+    /** Indexing */
+    index: z.ZodDefault<z.ZodBoolean>;
+    externalId: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "number" | "boolean" | "text" | "textarea" | "email" | "url" | "phone" | "password" | "markdown" | "html" | "currency" | "percent" | "date" | "datetime" | "time" | "select" | "multiselect" | "lookup" | "master_detail" | "image" | "file" | "avatar" | "formula" | "summary" | "autonumber";
+    label: string;
+    name: string;
+    required: boolean;
+    multiple: boolean;
+    unique: boolean;
+    deleteBehavior: "set_null" | "cascade" | "restrict";
+    hidden: boolean;
+    readonly: boolean;
+    encryption: boolean;
+    index: boolean;
+    externalId: boolean;
+    formula?: string | undefined;
+    options?: {
+        value: string;
+        label: string;
+        color?: string | undefined;
+        default?: boolean | undefined;
+    }[] | undefined;
+    description?: string | undefined;
+    defaultValue?: any;
+    maxLength?: number | undefined;
+    minLength?: number | undefined;
+    precision?: number | undefined;
+    scale?: number | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    reference?: string | undefined;
+    referenceFilters?: string[] | undefined;
+    writeRequiresMasterRead?: boolean | undefined;
+    expression?: string | undefined;
+    summaryOperations?: {
+        object: string;
+        function: "min" | "max" | "count" | "sum" | "avg";
+        field: string;
+    } | undefined;
+}, {
+    type: "number" | "boolean" | "text" | "textarea" | "email" | "url" | "phone" | "password" | "markdown" | "html" | "currency" | "percent" | "date" | "datetime" | "time" | "select" | "multiselect" | "lookup" | "master_detail" | "image" | "file" | "avatar" | "formula" | "summary" | "autonumber";
+    label: string;
+    name: string;
+    formula?: string | undefined;
+    options?: {
+        value: string;
+        label: string;
+        color?: string | undefined;
+        default?: boolean | undefined;
+    }[] | undefined;
+    description?: string | undefined;
+    required?: boolean | undefined;
+    multiple?: boolean | undefined;
+    unique?: boolean | undefined;
+    defaultValue?: any;
+    maxLength?: number | undefined;
+    minLength?: number | undefined;
+    precision?: number | undefined;
+    scale?: number | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    reference?: string | undefined;
+    referenceFilters?: string[] | undefined;
+    writeRequiresMasterRead?: boolean | undefined;
+    deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
+    expression?: string | undefined;
+    summaryOperations?: {
+        object: string;
+        function: "min" | "max" | "count" | "sum" | "avg";
+        field: string;
+    } | undefined;
+    hidden?: boolean | undefined;
+    readonly?: boolean | undefined;
+    encryption?: boolean | undefined;
+    index?: boolean | undefined;
+    externalId?: boolean | undefined;
+}>;
+export type Field = z.infer<typeof FieldSchema>;
+export type SelectOption = z.infer<typeof SelectOptionSchema>;
+//# sourceMappingURL=field.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"field.zod.d.ts","sourceRoot":"","sources":["../../src/data/field.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,SAAS,qRAmBpB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;EAK7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;IACtB,eAAe;;;;;IAMf,2BAA2B;;;;;IAM3B,8BAA8B;;;IAI9B,yBAAyB;;;;;IAMzB,wBAAwB;;;;;;;;;;;;;;;;;IAGxB,0BAA0B;;;;;IAM1B,kBAAkB;;;;;;;;;;;;;;;;IASlB,4BAA4B;;;;IAK5B,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGf,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAChD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/data/field.zod.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldSchema = exports.SelectOptionSchema = exports.FieldType = void 0;
+const zod_1 = require("zod");
+/**
+ * Field Type Enum
+ */
+exports.FieldType = zod_1.z.enum([
+    // Core Text
+    'text', 'textarea', 'email', 'url', 'phone', 'password',
+    // Rich Content
+    'markdown', 'html',
+    // Numbers
+    'number', 'currency', 'percent',
+    // Date & Time
+    'date', 'datetime', 'time',
+    // Logic
+    'boolean',
+    // Selection
+    'select', 'multiselect', // Static options
+    // Relational
+    'lookup', 'master_detail', // Dynamic reference to other objects
+    // Media
+    'image', 'file', 'avatar',
+    // Calculated / System
+    'formula', 'summary', 'autonumber'
+]);
+/**
+ * Select Option Schema
+ */
+exports.SelectOptionSchema = zod_1.z.object({
+    label: zod_1.z.string().describe('Display label'),
+    value: zod_1.z.string().describe('Stored value'),
+    color: zod_1.z.string().optional().describe('Color code for badges/charts'),
+    default: zod_1.z.boolean().optional().describe('Is default option'),
+});
+/**
+ * Field Schema - Best Practice Enterprise Pattern
+ */
+exports.FieldSchema = zod_1.z.object({
+    /** Identity */
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Machine name (snake_case)'),
+    label: zod_1.z.string().describe('Human readable label'),
+    type: exports.FieldType.describe('Field Data Type'),
+    description: zod_1.z.string().optional().describe('Tooltip/Help text'),
+    /** Database Constraints */
+    required: zod_1.z.boolean().default(false).describe('Is required'),
+    multiple: zod_1.z.boolean().default(false).describe('Allow multiple values (Stores as Array/JSON). Applicable for select, lookup, file, image.'),
+    unique: zod_1.z.boolean().default(false).describe('Is unique constraint'),
+    defaultValue: zod_1.z.any().optional().describe('Default value'),
+    /** Text/String Constraints */
+    maxLength: zod_1.z.number().optional().describe('Max character length'),
+    minLength: zod_1.z.number().optional().describe('Min character length'),
+    /** Number Constraints */
+    precision: zod_1.z.number().optional().describe('Total digits'),
+    scale: zod_1.z.number().optional().describe('Decimal places'),
+    min: zod_1.z.number().optional().describe('Minimum value'),
+    max: zod_1.z.number().optional().describe('Maximum value'),
+    /** Selection Options */
+    options: zod_1.z.array(exports.SelectOptionSchema).optional().describe('Static options for select/multiselect'),
+    /** Relationship Config */
+    reference: zod_1.z.string().optional().describe('Target Object Name'),
+    referenceFilters: zod_1.z.array(zod_1.z.string()).optional().describe('Filters applied to lookup dialogs (e.g. "active = true")'),
+    writeRequiresMasterRead: zod_1.z.boolean().optional().describe('If true, user needs read access to master record to edit this field'),
+    deleteBehavior: zod_1.z.enum(['set_null', 'cascade', 'restrict']).optional().default('set_null').describe('What happens if referenced record is deleted'),
+    /** Calculation */
+    expression: zod_1.z.string().optional().describe('Formula expression'), // Changed from formula to expression to match common usage, but keeping one consistent is key. Let's use expression as generic.
+    formula: zod_1.z.string().optional().describe('Deprecated: Use expression'), // Backwards compat or just keep.
+    summaryOperations: zod_1.z.object({
+        object: zod_1.z.string(),
+        field: zod_1.z.string(),
+        function: zod_1.z.enum(['count', 'sum', 'min', 'max', 'avg'])
+    }).optional().describe('Roll-up summary definition'),
+    /** Security & Visibility */
+    hidden: zod_1.z.boolean().default(false).describe('Hidden from default UI'),
+    readonly: zod_1.z.boolean().default(false).describe('Read-only in UI'),
+    encryption: zod_1.z.boolean().default(false).describe('Encrypt at rest'),
+    /** Indexing */
+    index: zod_1.z.boolean().default(false).describe('Create standard database index'),
+    externalId: zod_1.z.boolean().default(false).describe('Is external ID for upsert operations'),
+});

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

@@ -0,0 +1,242 @@
+import { z } from 'zod';
+/**
+ * Flow Node Types
+ */
+export declare const FlowNodeAction: z.ZodEnum<["start", "end", "decision", "assignment", "loop", "create_record", "update_record", "delete_record", "get_record", "http_request", "script", "wait", "subflow"]>;
+/**
+ * Flow Variable Schema
+ * Variables available within the flow execution context.
+ */
+export declare const FlowVariableSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    isInput: z.ZodDefault<z.ZodBoolean>;
+    isOutput: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    name: string;
+    isInput: boolean;
+    isOutput: boolean;
+}, {
+    type: string;
+    name: string;
+    isInput?: boolean | undefined;
+    isOutput?: boolean | undefined;
+}>;
+/**
+ * Flow Node Schema
+ * A single step in the visual logic graph.
+ */
+export declare const FlowNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["start", "end", "decision", "assignment", "loop", "create_record", "update_record", "delete_record", "get_record", "http_request", "script", "wait", "subflow"]>;
+    label: z.ZodString;
+    /** Node Configuration Options (Specific to type) */
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    /** UI Position (for the canvas) */
+    position: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "script" | "start" | "end" | "decision" | "assignment" | "loop" | "create_record" | "update_record" | "delete_record" | "get_record" | "http_request" | "wait" | "subflow";
+    label: string;
+    id: string;
+    config?: Record<string, any> | undefined;
+    position?: {
+        x: number;
+        y: number;
+    } | undefined;
+}, {
+    type: "script" | "start" | "end" | "decision" | "assignment" | "loop" | "create_record" | "update_record" | "delete_record" | "get_record" | "http_request" | "wait" | "subflow";
+    label: string;
+    id: string;
+    config?: Record<string, any> | undefined;
+    position?: {
+        x: number;
+        y: number;
+    } | undefined;
+}>;
+/**
+ * Flow Edge Schema
+ * Connections between nodes.
+ */
+export declare const FlowEdgeSchema: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    target: z.ZodString;
+    /** Condition for this path (only for decision/branch nodes) */
+    condition: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    source: string;
+    target: string;
+    label?: string | undefined;
+    condition?: string | undefined;
+}, {
+    id: string;
+    source: string;
+    target: string;
+    label?: string | undefined;
+    condition?: string | undefined;
+}>;
+/**
+ * Flow Schema
+ * Visual Business Logic Orchestration.
+ */
+export declare const FlowSchema: z.ZodObject<{
+    /** Identity */
+    name: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    /** Trigger Type */
+    type: z.ZodEnum<["autolaunched", "record_change", "schedule", "screen", "api"]>;
+    /** Configuration Variables */
+    variables: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        isInput: z.ZodDefault<z.ZodBoolean>;
+        isOutput: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        name: string;
+        isInput: boolean;
+        isOutput: boolean;
+    }, {
+        type: string;
+        name: string;
+        isInput?: boolean | undefined;
+        isOutput?: boolean | undefined;
+    }>, "many">>;
+    /** Graph Definition */
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["start", "end", "decision", "assignment", "loop", "create_record", "update_record", "delete_record", "get_record", "http_request", "script", "wait", "subflow"]>;
+        label: z.ZodString;
+        /** Node Configuration Options (Specific to type) */
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        /** UI Position (for the canvas) */
+        position: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            x: number;
+            y: number;
+        }, {
+            x: number;
+            y: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "script" | "start" | "end" | "decision" | "assignment" | "loop" | "create_record" | "update_record" | "delete_record" | "get_record" | "http_request" | "wait" | "subflow";
+        label: string;
+        id: string;
+        config?: Record<string, any> | undefined;
+        position?: {
+            x: number;
+            y: number;
+        } | undefined;
+    }, {
+        type: "script" | "start" | "end" | "decision" | "assignment" | "loop" | "create_record" | "update_record" | "delete_record" | "get_record" | "http_request" | "wait" | "subflow";
+        label: string;
+        id: string;
+        config?: Record<string, any> | undefined;
+        position?: {
+            x: number;
+            y: number;
+        } | undefined;
+    }>, "many">;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        target: z.ZodString;
+        /** Condition for this path (only for decision/branch nodes) */
+        condition: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        source: string;
+        target: string;
+        label?: string | undefined;
+        condition?: string | undefined;
+    }, {
+        id: string;
+        source: string;
+        target: string;
+        label?: string | undefined;
+        condition?: string | undefined;
+    }>, "many">;
+    /** Execution Config */
+    active: z.ZodDefault<z.ZodBoolean>;
+    runAs: z.ZodDefault<z.ZodEnum<["system", "user"]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "schedule" | "autolaunched" | "record_change" | "screen" | "api";
+    label: string;
+    name: string;
+    active: boolean;
+    nodes: {
+        type: "script" | "start" | "end" | "decision" | "assignment" | "loop" | "create_record" | "update_record" | "delete_record" | "get_record" | "http_request" | "wait" | "subflow";
+        label: string;
+        id: string;
+        config?: Record<string, any> | undefined;
+        position?: {
+            x: number;
+            y: number;
+        } | undefined;
+    }[];
+    edges: {
+        id: string;
+        source: string;
+        target: string;
+        label?: string | undefined;
+        condition?: string | undefined;
+    }[];
+    runAs: "system" | "user";
+    description?: string | undefined;
+    variables?: {
+        type: string;
+        name: string;
+        isInput: boolean;
+        isOutput: boolean;
+    }[] | undefined;
+}, {
+    type: "schedule" | "autolaunched" | "record_change" | "screen" | "api";
+    label: string;
+    name: string;
+    nodes: {
+        type: "script" | "start" | "end" | "decision" | "assignment" | "loop" | "create_record" | "update_record" | "delete_record" | "get_record" | "http_request" | "wait" | "subflow";
+        label: string;
+        id: string;
+        config?: Record<string, any> | undefined;
+        position?: {
+            x: number;
+            y: number;
+        } | undefined;
+    }[];
+    edges: {
+        id: string;
+        source: string;
+        target: string;
+        label?: string | undefined;
+        condition?: string | undefined;
+    }[];
+    description?: string | undefined;
+    active?: boolean | undefined;
+    variables?: {
+        type: string;
+        name: string;
+        isInput?: boolean | undefined;
+        isOutput?: boolean | undefined;
+    }[] | undefined;
+    runAs?: "system" | "user" | undefined;
+}>;
+export type Flow = z.infer<typeof FlowSchema>;
+export type FlowNode = z.infer<typeof FlowNodeSchema>;
+export type FlowEdge = z.infer<typeof FlowEdgeSchema>;
+//# sourceMappingURL=flow.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flow.zod.d.ts","sourceRoot":"","sources":["../../src/data/flow.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,cAAc,6KAczB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;EAK7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;IAKzB,oDAAoD;;IAGpD,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEnC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;IAKzB,+DAA+D;;;;;;;;;;;;;;;EAI/D,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,UAAU;IACrB,eAAe;;;;IAKf,mBAAmB;;IAGnB,8BAA8B;;;;;;;;;;;;;;;;;IAG9B,uBAAuB;;;;;QAtCvB,oDAAoD;;QAGpD,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAanC,+DAA+D;;;;;;;;;;;;;;;;IA0B/D,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvB,CAAC;AAEH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/data/flow.zod.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowSchema = exports.FlowEdgeSchema = exports.FlowNodeSchema = exports.FlowVariableSchema = exports.FlowNodeAction = void 0;
+const zod_1 = require("zod");
+/**
+ * Flow Node Types
+ */
+exports.FlowNodeAction = zod_1.z.enum([
+    'start', // Trigger
+    'end', // Return/Stop
+    'decision', // If/Else logic
+    'assignment', // Set Variable
+    'loop', // For Each
+    'create_record', // CRUD: Create
+    'update_record', // CRUD: Update
+    'delete_record', // CRUD: Delete
+    'get_record', // CRUD: Get/Query
+    'http_request', // Webhook/API Call
+    'script', // Custom Script (JS/TS)
+    'wait', // Delay/Sleep
+    'subflow' // Call another flow
+]);
+/**
+ * Flow Variable Schema
+ * Variables available within the flow execution context.
+ */
+exports.FlowVariableSchema = zod_1.z.object({
+    name: zod_1.z.string().describe('Variable name'),
+    type: zod_1.z.string().describe('Data type (text, number, boolean, object, list)'),
+    isInput: zod_1.z.boolean().default(false).describe('Is input parameter'),
+    isOutput: zod_1.z.boolean().default(false).describe('Is output parameter'),
+});
+/**
+ * Flow Node Schema
+ * A single step in the visual logic graph.
+ */
+exports.FlowNodeSchema = zod_1.z.object({
+    id: zod_1.z.string().describe('Node unique ID'),
+    type: exports.FlowNodeAction.describe('Action type'),
+    label: zod_1.z.string().describe('Node label'),
+    /** Node Configuration Options (Specific to type) */
+    config: zod_1.z.record(zod_1.z.any()).optional().describe('Node configuration'),
+    /** UI Position (for the canvas) */
+    position: zod_1.z.object({ x: zod_1.z.number(), y: zod_1.z.number() }).optional(),
+});
+/**
+ * Flow Edge Schema
+ * Connections between nodes.
+ */
+exports.FlowEdgeSchema = zod_1.z.object({
+    id: zod_1.z.string().describe('Edge unique ID'),
+    source: zod_1.z.string().describe('Source Node ID'),
+    target: zod_1.z.string().describe('Target Node ID'),
+    /** Condition for this path (only for decision/branch nodes) */
+    condition: zod_1.z.string().optional().describe('Expression returning boolean used for branching'),
+    label: zod_1.z.string().optional().describe('Label on the connector'),
+});
+/**
+ * Flow Schema
+ * Visual Business Logic Orchestration.
+ */
+exports.FlowSchema = zod_1.z.object({
+    /** Identity */
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Machine name'),
+    label: zod_1.z.string().describe('Flow label'),
+    description: zod_1.z.string().optional(),
+    /** Trigger Type */
+    type: zod_1.z.enum(['autolaunched', 'record_change', 'schedule', 'screen', 'api']).describe('Flow type'),
+    /** Configuration Variables */
+    variables: zod_1.z.array(exports.FlowVariableSchema).optional().describe('Flow variables'),
+    /** Graph Definition */
+    nodes: zod_1.z.array(exports.FlowNodeSchema).describe('Flow nodes'),
+    edges: zod_1.z.array(exports.FlowEdgeSchema).describe('Flow connections'),
+    /** Execution Config */
+    active: zod_1.z.boolean().default(false).describe('Is active'),
+    runAs: zod_1.z.enum(['system', 'user']).default('user').describe('Execution context'),
+});